diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 267f0b62e..a6c2e361f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -86,6 +86,10 @@ jobs:
           use-github-cache: false
       - name: Test Ix CLI
         run: lake test --wfail -- cli
+      - name: Test Ixon v3 contracts and consumers
+        run: |
+          lake exe ixon-v3-primitives
+          lake exe ixon-v3-tests --primitives
 
   rust-test:
     runs-on: warp-ubuntu-latest-x64-8x
diff --git a/.gitignore b/.gitignore
index 0f1815e05..22003795f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -10,6 +10,7 @@ result*
 
 #Ix
 *.ixe
+!Tests/Fixtures/ixon-v3/handoff/*.ixe
 plans
 refs
 
diff --git a/Ix/Aggr/Circuit.lean b/Ix/Aggr/Circuit.lean
index b351c22fc..3bfccaac2 100644
--- a/Ix/Aggr/Circuit.lean
+++ b/Ix/Aggr/Circuit.lean
@@ -533,6 +533,10 @@ def circuit := ⟦
   fn aggr_parse_check_env(bytes: ByteStream) -> (Addr, Option‹Addr›) {
     let (tag, s) = aggr_read_byte(bytes);
     assert_eq!(tag, 0xE5u8, "aggr: claim is not CheckEnv");
+    let (format, s) = aggr_read_byte(s);
+    assert_eq!(format, 3u8, "aggr: unsupported object format");
+    let (validator, s) = aggr_read_byte(s);
+    assert_eq!(validator, 1u8, "aggr: wrong validator identity");
     let (root, s2) = aggr_read_address(s);
     let (assumptions, stop) = aggr_get_opt_address(s2);
     assert_eq!(load(stop), ListNode.Nil,
@@ -800,3 +804,4 @@ def circuit := ⟦
 end Aggr
 
 end
+
diff --git a/Ix/CanonM.lean b/Ix/CanonM.lean
index 840d379f9..402bf4a07 100644
--- a/Ix/CanonM.lean
+++ b/Ix/CanonM.lean
@@ -19,6 +19,7 @@ module
 
 public import Ix.Common
 public import Ix.Environment
+public import Ix.SemanticContract
 public import Ix.Address
 
 public section
@@ -600,8 +601,10 @@ partial def exprEqCached (a b : Lean.Expr) : EqState Bool := do
       if !(← exprEqCached valA valB) then return false
       exprEqCached bodyA bodyB
     | .lit lA, .lit lB => pure (lA == lB)
-    -- Mdata entries are ignored for semantic equality (they carry annotations, not semantics)
-    | .mdata _ eA, .mdata _ eB => exprEqCached eA eB
+    -- Presentation metadata is transparent; effective contracts are semantic.
+    | .mdata dataA eA, .mdata dataB eB => do
+      if SemanticContract.leanFields dataA != SemanticContract.leanFields dataB then return false
+      exprEqCached eA eB
     | .proj tnA idxA sA, .proj tnB idxB sB =>
       if tnA != tnB || idxA != idxB then return false
       exprEqCached sA sB
@@ -773,3 +776,4 @@ def uncanonEnvParallel (consts : HashMap Ix.Name Ix.ConstantInfo) (numWorkers :
 end Ix.CanonM
 
 end
+
diff --git a/Ix/Catalog.lean b/Ix/Catalog.lean
index b9d893717..9b02b51bb 100644
--- a/Ix/Catalog.lean
+++ b/Ix/Catalog.lean
@@ -44,8 +44,8 @@ open Ixon (PutM GetM putU8 getU8 putBytes getBytes runPut runGet)
 /-- Magic bytes at the head of every `.ixc` file. -/
 def MAGIC : ByteArray := String.toUTF8 "IXC" ++ ⟨#[0, 0, 0, 0, 0]⟩
 
-/-- `.ixc` format version. -/
-def VERSION : UInt32 := 1
+/-- Manifest v2 binds Ixon v3 and erased-lean-v1 catalog claims. -/
+def VERSION : UInt32 := 2
 
 /-- Storage-profile flag: bit0 of the header `flags` word. -/
 def FLAG_CHUNKED : UInt32 := 1
@@ -185,6 +185,8 @@ def ser (c : Catalog) : ByteArray := runPut do
   putU32LE (match c.storage with
     | .chunked _ => FLAG_CHUNKED
     | .fat _ => 0)
+  putU8 3
+  putU8 1
   putAddr c.membersRoot
   putAddr c.contentRoot
   putU32LE c.members.size.toUInt32
@@ -245,6 +247,8 @@ where
       let flags ← getU32LE
       if flags &&& (~~~FLAG_CHUNKED) != 0 then
         throw s!"unknown .ixc flags {flags}"
+      unless (← getU8) == 3 do throw "catalog: unsupported object format"
+      unless (← getU8) == 1 do throw "catalog: wrong validator identity"
       let membersRoot ← getAddr
       let contentRoot ← getAddr
       let memberCount ← getU32LE
diff --git a/Ix/Claim.lean b/Ix/Claim.lean
index 7e2d016eb..f11a54b5d 100644
--- a/Ix/Claim.lean
+++ b/Ix/Claim.lean
@@ -154,6 +154,9 @@ inductive Claim where
   | reveal   (comm : Address) (info : RevealConstantInfo)
   | contains (tree : Address) (const : Address)
   | catalog  (members content : Address) (assumptions : Option Address)
+  /-- Combined erased typing and resource admission of the complete addressed
+  environment under the profile committed by `profile`. -/
+  | resource (root profile : Address)
   deriving BEq, Repr, Inhabited
 
 -- ============================================================================
@@ -478,6 +481,7 @@ def VARIANT_CHECK_ENV_CLAIM  : UInt64 := 5
 def VARIANT_REVEAL_CLAIM     : UInt64 := 6
 def VARIANT_CONTAINS_CLAIM   : UInt64 := 7
 def VARIANT_CATALOG_CLAIM    : UInt64 := 8
+def VARIANT_RESOURCE_CLAIM   : UInt64 := 9
 
 def VARIANT_EVAL_PROOF       : UInt64 := 0
 def VARIANT_CHECK_PROOF      : UInt64 := 1
@@ -485,6 +489,7 @@ def VARIANT_CHECK_ENV_PROOF  : UInt64 := 2
 def VARIANT_REVEAL_PROOF     : UInt64 := 3
 def VARIANT_CONTAINS_PROOF   : UInt64 := 4
 def VARIANT_CATALOG_PROOF    : UInt64 := 5
+def VARIANT_RESOURCE_PROOF   : UInt64 := 6
 
 /-- Encode an `Option Address` as `[0x00]` (none) or `[0x01][addr:32]`
     (some). Mirrors `put_opt_addr` in src/ix/ixon/proof.rs. -/
@@ -498,39 +503,64 @@ def getOptAddr : GetM (Option Address) := do
   else if b == 0x01 then return some (← Serialize.get)
   else throw s!"getOptAddr: invalid tag {b}"
 
-def put : Claim → PutM Unit
+/-- Claim and proof payloads bind both the object format and the validator.
+0 is structural-v1, 1 is erased-lean-v1, 2 is resource-v1. -/
+def validatorForVariant (variant : UInt64) : UInt8 :=
+  if variant == VARIANT_REVEAL_CLAIM || variant == VARIANT_CONTAINS_CLAIM then 0
+  else if variant == VARIANT_RESOURCE_CLAIM then 2
+  else 1
+
+def variantOf : Claim → UInt64
+  | .eval .. => VARIANT_EVAL_CLAIM
+  | .check .. => VARIANT_CHECK_CLAIM
+  | .checkEnv .. => VARIANT_CHECK_ENV_CLAIM
+  | .reveal .. => VARIANT_REVEAL_CLAIM
+  | .contains .. => VARIANT_CONTAINS_CLAIM
+  | .catalog .. => VARIANT_CATALOG_CLAIM
+  | .resource .. => VARIANT_RESOURCE_CLAIM
+
+def putScope (validator : UInt8) : PutM Unit := do
+  putU8 3
+  putU8 validator
+
+def getScope (validator : UInt8) : GetM Unit := do
+  unless (← getU8) == 3 do throw "claim: unsupported object format"
+  unless (← getU8) == validator do throw "claim: wrong validator identity"
+
+def put (claim : Claim) : PutM Unit := do
+  putTag4 ⟨FLAG_CLAIM, variantOf claim⟩
+  putScope (validatorForVariant (variantOf claim))
+  match claim with
   | .eval input output assumptions => do
-    putTag4 ⟨FLAG_CLAIM, VARIANT_EVAL_CLAIM⟩
     Serialize.put input
     Serialize.put output
     putOptAddr assumptions
   | .check const assumptions => do
-    putTag4 ⟨FLAG_CLAIM, VARIANT_CHECK_CLAIM⟩
     Serialize.put const
     putOptAddr assumptions
   | .checkEnv root assumptions => do
-    putTag4 ⟨FLAG_CLAIM, VARIANT_CHECK_ENV_CLAIM⟩
     Serialize.put root
     putOptAddr assumptions
   | .reveal comm info => do
-    putTag4 ⟨FLAG_CLAIM, VARIANT_REVEAL_CLAIM⟩
     Serialize.put comm
     RevealConstantInfo.put info
   | .contains tree const => do
-    putTag4 ⟨FLAG_CLAIM, VARIANT_CONTAINS_CLAIM⟩
     Serialize.put tree
     Serialize.put const
   | .catalog members content assumptions => do
     -- First multi-byte claim tag: 0xE8 0x08 on the wire.
-    putTag4 ⟨FLAG_CLAIM, VARIANT_CATALOG_CLAIM⟩
     Serialize.put members
     Serialize.put content
     putOptAddr assumptions
+  | .resource root profile => do
+    Serialize.put root
+    Serialize.put profile
 
 def get : GetM Claim := do
   let tag ← getTag4
   if tag.flag != FLAG_CLAIM then
     throw s!"Claim.get: expected flag 0xE, got {tag.flag}"
+  getScope (validatorForVariant tag.size)
   if tag.size == VARIANT_EVAL_CLAIM then
     let input ← Serialize.get
     let output ← Serialize.get
@@ -553,10 +583,13 @@ def get : GetM Claim := do
     let content ← Serialize.get
     let asm ← getOptAddr
     return .catalog members content asm
+  else if tag.size == VARIANT_RESOURCE_CLAIM then
+    return .resource (← Serialize.get) (← Serialize.get)
   else
     throw s!"Claim.get: invalid claim variant {tag.size}"
 
 def ser (c : Claim) : ByteArray := runPut (put c)
+def de (bytes : ByteArray) : Except String Claim := runGetExact get bytes
 def commit (c : Claim) : Address := Address.blake3 (ser c)
 
 instance : ToString Claim where
@@ -567,6 +600,7 @@ instance : ToString Claim where
     | .reveal comm info => s!"Reveal({comm}, {repr info})"
     | .contains t c => s!"Contains({t}, {c})"
     | .catalog m c asm => s!"Catalog({m}, {c}, {asm})"
+    | .resource root profile => s!"Resource({root}, {profile})"
 
 end Claim
 
@@ -596,9 +630,11 @@ def variantOf : Ix.Claim → UInt64
   | .reveal _ _     => Ix.Claim.VARIANT_REVEAL_PROOF
   | .contains _ _   => Ix.Claim.VARIANT_CONTAINS_PROOF
   | .catalog _ _ _  => Ix.Claim.VARIANT_CATALOG_PROOF
+  | .resource _ _   => Ix.Claim.VARIANT_RESOURCE_PROOF
 
 def put (p : Proof) : PutM Unit := do
   putTag4 ⟨Ix.Claim.FLAG_PROOF, variantOf p.claim⟩
+  Ix.Claim.putScope (Ix.Claim.validatorForVariant (Ix.Claim.variantOf p.claim))
   match p.claim with
   | .eval input output asm => do
     Serialize.put input
@@ -620,6 +656,9 @@ def put (p : Proof) : PutM Unit := do
     Serialize.put members
     Serialize.put content
     Ix.Claim.putOptAddr asm
+  | .resource root profile => do
+    Serialize.put root
+    Serialize.put profile
   putTag0 ⟨p.proof.size.toUInt64⟩
   putBytes p.proof
 
@@ -627,6 +666,7 @@ def get : GetM Proof := do
   let tag ← getTag4
   if tag.flag != Ix.Claim.FLAG_PROOF then
     throw s!"Ixon.Proof.get: expected flag 0xF, got {tag.flag}"
+  Ix.Claim.getScope (Ix.Claim.validatorForVariant (tag.size + 3))
   let claim : Ix.Claim ←
     if tag.size == Ix.Claim.VARIANT_EVAL_PROOF then do
       let input ← Serialize.get
@@ -654,6 +694,8 @@ def get : GetM Proof := do
       let content ← Serialize.get
       let asm ← Ix.Claim.getOptAddr
       pure (.catalog members content asm)
+    else if tag.size == Ix.Claim.VARIANT_RESOURCE_PROOF then do
+      pure (.resource (← Serialize.get) (← Serialize.get))
     else
       throw s!"Ixon.Proof.get: invalid proof variant {tag.size}"
   let lenTag ← getTag0
@@ -661,10 +703,11 @@ def get : GetM Proof := do
   pure { claim, proof := bytes }
 
 def ser (p : Proof) : ByteArray := runPut (put p)
-def de (bytes : ByteArray) : Except String Proof := runGet get bytes
+def de (bytes : ByteArray) : Except String Proof := runGetExact get bytes
 
 end Proof
 
 end Ixon
 
 end
+
diff --git a/Ix/Cli/CompileCmd.lean b/Ix/Cli/CompileCmd.lean
index a7998f594..2399302db 100644
--- a/Ix/Cli/CompileCmd.lean
+++ b/Ix/Cli/CompileCmd.lean
@@ -158,6 +158,7 @@ def runCompileCmd (p : Cli.Parsed) : IO UInt32 := do
   let allowPartial := p.hasFlag "allow-partial"
   let strictAnon := p.hasFlag "anon"
   let start ← IO.monoMsNow
+  let constList ← IO.ofExcept <| Ix.Compile.prepareRegisteredConstants leanEnv constList
   let status ← if strictAnon then
       Ix.CompileM.rsCompileEnvBytesAnonFFI constList outPath allowPartial
     else
@@ -262,3 +263,4 @@ def compileCmd : Cli.Cmd := `[Cli|
 ]
 
 end
+
diff --git a/Ix/Cli/CompileLeanCmd.lean b/Ix/Cli/CompileLeanCmd.lean
index 23c807aea..a08fb4736 100644
--- a/Ix/Cli/CompileLeanCmd.lean
+++ b/Ix/Cli/CompileLeanCmd.lean
@@ -53,7 +53,8 @@ def runCompileLeanCmd (p : Cli.Parsed) : IO UInt32 := do
   IO.println s!"[compile-lean] {constList.length} constants, {workers} workers"
 
   let t0 ← IO.monoMsNow
-  match ← Ix.CompileM.compileLeanConsts constList (numWorkers := workers)
+  let input ← IO.ofExcept ((Ix.Compile.compileInputFromEnv fe.env constList).mapError toString)
+  match ← Ix.CompileM.compileLeanInput input (numWorkers := workers)
       (dbg := true) with
   | .error e =>
     IO.println s!"[compile-lean] FAILED: {e}"
@@ -85,7 +86,8 @@ serialize the grounded subset)"
       let tR ← IO.monoMsNow
       let dir ← IO.FS.createTempDir
       let rustOut := dir / "rust-check.ixe"
-      let _ ← Ix.CompileM.rsCompileEnvBytesFFI constList rustOut.toString true
+      let constants ← IO.ofExcept input.prepare
+      let _ ← Ix.CompileM.rsCompileEnvBytesFFI constants rustOut.toString true
       let rustBytes ← IO.FS.readBinFile rustOut
       IO.FS.removeDirAll dir
       let tRe := (← IO.monoMsNow) - tR
@@ -120,3 +122,4 @@ def compileLeanCmd : Cli.Cmd := `[Cli|
 ]
 
 end
+
diff --git a/Ix/Compile/SourceContract.lean b/Ix/Compile/SourceContract.lean
new file mode 100644
index 000000000..5971fd4ad
--- /dev/null
+++ b/Ix/Compile/SourceContract.lean
@@ -0,0 +1,4 @@
+module
+
+public import Ix.Compile.SourceContract.Basic
+public import Ix.Compile.SourceContract.Resolve
diff --git a/Ix/Compile/SourceContract/Basic.lean b/Ix/Compile/SourceContract/Basic.lean
new file mode 100644
index 000000000..76547b18d
--- /dev/null
+++ b/Ix/Compile/SourceContract/Basic.lean
@@ -0,0 +1,201 @@
+module
+
+public import Ix.IxonContract
+
+/-!
+# Source contracts before canonicalization
+
+These records refer to elaborated source syntax, before source sharing,
+canonicalization, specialization, or erasure. They carry intent; they do not
+prove that a term satisfies a usage or ownership discipline.
+
+The input owns both its selected constants and its explicit contract registry.
+No environment extension or source file is needed to validate this data.
+-/
+
+public section
+
+namespace Ix.Compile
+
+/-- The two expression roots of a source declaration. -/
+inductive SourceRoot where
+  | type
+  | body
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable, Ord
+
+/-- A structural edge in the elaborated expression tree. Metadata wrappers
+are explicit edges, so two occurrences of an equal subterm stay distinct. -/
+inductive SourceStep where
+  | appFn
+  | appArg
+  | binderType
+  | binderBody
+  | letType
+  | letValue
+  | letBody
+  | metadata
+  | projection
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable, Ord
+
+/-- A binder occurrence, independent of its name or source location. -/
+structure BinderSite where
+  root : SourceRoot
+  path : List SourceStep := []
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable, Ord
+
+inductive SourceBinderKind where
+  | lam
+  | all
+  | letE
+  deriving BEq, DecidableEq, Repr, Inhabited
+
+/-- Independent input and result value contracts. A borrow kind is meaningful
+only at a let occurrence; locality alone never creates a loan. -/
+structure BinderContract where
+  site : BinderSite
+  uses : Ixon.Uses
+  result : Option Ixon.ValueContract := none
+  value : Ixon.ValueContract := .shared
+  letKind : Ixon.LetKind := .value
+  deriving BEq, Repr, Inhabited
+
+/-- Contract binding uses an exact source snapshot, including the type, body,
+universe parameters, binder information, and metadata. The snapshot is shared
+Lean data, not a second environment. In particular, a 64-bit expression hash
+alone cannot authorize reusing contracts for different source syntax. -/
+structure SourceContract where
+  source : Lean.ConstantInfo
+  binders : Array BinderContract
+  deriving Repr, Inhabited
+
+/-- User-facing selectors are resolved once to elaborated telescope positions.
+Positions are zero-based and include implicit and instance arguments. -/
+inductive BinderSelector where
+  | position (index : Nat)
+  | name (name : Lean.Name)
+  deriving BEq, Repr, Inhabited
+
+/-- Declaration shorthand that annotates corresponding type/body binders.
+The input contract applies to both occurrences; the independent result
+contract applies only to this position's arrow. -/
+structure TelescopeContract where
+  binder : BinderSelector
+  uses : Ixon.Uses
+  result : Option Ixon.ValueContract := none
+  value : Ixon.ValueContract := .shared
+  letKind : Ixon.LetKind := .value
+  deriving Repr, Inhabited
+
+/-- Optional recursion information, bound to the exact source declaration.
+The argument position includes erased, implicit, and instance binders. A
+fixed-step proposal neither inserts fuel nor certifies target termination. -/
+structure MeasureHint where
+  source : Lean.ConstantInfo
+  argument : BinderSelector
+  fixedStep : Option Nat := none
+  deriving Repr, Inhabited
+
+/-- Pure frontend input. Semantic contracts have no implicit empty default.
+Plain-source callers must opt into the explicitly named convenience API. -/
+structure CompileInput where
+  constants : List (Lean.Name × Lean.ConstantInfo)
+  contracts : Array SourceContract
+  measureHints : Array MeasureHint := #[]
+
+def CompileInput.plain (constants : List (Lean.Name × Lean.ConstantInfo)) : CompileInput :=
+  { constants, contracts := #[] }
+
+/-- Diagnostic names and binder information are retained after resolving a
+site. On arrows, result is always populated, including the shared default.
+On lambdas and lets it is absent. -/
+structure ResolvedBinderContract where
+  site : BinderSite
+  kind : SourceBinderKind
+  name : Lean.Name
+  binderInfo : Lean.BinderInfo
+  uses : Ixon.Uses
+  result : Option Ixon.ValueContract
+  value : Ixon.ValueContract
+  letKind : Ixon.LetKind
+  deriving Repr, Inhabited
+
+structure ResolvedSourceContract where
+  source : Lean.ConstantInfo
+  binders : Array ResolvedBinderContract
+  deriving Repr, Inhabited
+
+/-- The resolved assertion at one source occurrence, without diagnostic names.
+This is source contract data, not an Ixon expression or wire encoding. -/
+structure BinderContractSemantics where
+  site : BinderSite
+  kind : SourceBinderKind
+  uses : Ixon.Uses
+  result : Option Ixon.ValueContract
+  value : Ixon.ValueContract
+  letKind : Ixon.LetKind
+  deriving BEq, Repr, Inhabited
+
+/-- Names and the exact source snapshot belong to validation and diagnostics.
+Source paths still refer to the elaborated tree; do not hash this as an artifact. -/
+structure SourceContractSemantics where
+  binders : Array BinderContractSemantics
+  deriving BEq, Repr, Inhabited
+
+def ResolvedSourceContract.semantics (contract : ResolvedSourceContract) : SourceContractSemantics :=
+  { binders := contract.binders.map fun binder => {
+      site := binder.site, kind := binder.kind, uses := binder.uses
+      result := binder.result, value := binder.value, letKind := binder.letKind } }
+
+structure ResolvedMeasureHint where
+  source : Lean.ConstantInfo
+  argument : Nat
+  site : BinderSite
+  fixedStep : Option Nat
+  deriving Repr, Inhabited
+
+/-- Validation output for transport into a compiler. A consumer accepting
+untrusted serialized records must rerun validation; a record is not a proof. -/
+structure ResolvedCompileInput where
+  constants : List (Lean.Name × Lean.ConstantInfo)
+  contracts : Array ResolvedSourceContract
+  measureHints : Array ResolvedMeasureHint
+
+inductive SourceContractError where
+  | missingDeclaration (name : Lean.Name)
+  | duplicateDeclaration (name : Lean.Name)
+  | declarationNameMismatch (key actual : Lean.Name)
+  | duplicateContract (name : Lean.Name)
+  | staleSource (name : Lean.Name)
+  | invalidSite (name : Lean.Name) (site : BinderSite)
+  | expectedBinder (name : Lean.Name) (site : BinderSite)
+  | resultOnNonArrow (name : Lean.Name) (site : BinderSite)
+  | borrowOnNonLet (name : Lean.Name) (site : BinderSite)
+  | invalidBorrowView (name : Lean.Name) (site : BinderSite)
+  | duplicateSite (name : Lean.Name) (site : BinderSite)
+  | argumentOutOfRange (name : Lean.Name) (index : Nat)
+  | unknownBinder (declaration binder : Lean.Name)
+  | ambiguousBinder (declaration binder : Lean.Name)
+  | missingBodyBinder (name : Lean.Name) (index : Nat)
+  | inconsistentTelescope (name : Lean.Name) (index : Nat)
+      (typeUses bodyUses : Ixon.Uses)
+  | inconsistentValue (name : Lean.Name) (index : Nat)
+      (typeValue bodyValue : Ixon.ValueContract)
+  | annotatedRecursorRule (declaration : Lean.Name)
+  | malformedAnnotation (declaration : Lean.Name) (site : BinderSite) (reason : String)
+  | misplacedAnnotation (declaration : Lean.Name) (site : BinderSite)
+  | annotationBinderMismatch (declaration : Lean.Name) (site : BinderSite)
+      (expected actual : Lean.Name)
+  | duplicateAnnotation (declaration : Lean.Name) (root : SourceRoot) (origin : Nat)
+  | missingAnnotation (declaration : Lean.Name) (site : BinderSite)
+  | conflictingAnnotation (declaration : Lean.Name) (site : BinderSite)
+  | missingContract (declaration : Lean.Name)
+  | duplicateMeasure (name : Lean.Name)
+  | zeroFixedStep (name : Lean.Name)
+  deriving BEq, Repr
+
+instance : ToString SourceContractError where
+  toString error := s!"source contract: {repr error}"
+
+end Ix.Compile
+
+end
diff --git a/Ix/Compile/SourceContract/Elab.lean b/Ix/Compile/SourceContract/Elab.lean
new file mode 100644
index 000000000..c20ffdd9b
--- /dev/null
+++ b/Ix/Compile/SourceContract/Elab.lean
@@ -0,0 +1,236 @@
+module
+
+public import Ix.Compile.SourceContract.Registry
+public import Ix.Compile.SourceContract.Syntax
+public meta import Ix.Compile.SourceContract.Registry
+public meta import Ix.Compile.SourceContract.Syntax
+
+/-!
+# Source binder elaboration
+
+Opt-in syntax for declaration binders. Lean elaborates the ordinary declaration;
+source markers record its binder contracts, which are then registered from the
+actual elaborated occurrences. No resource checker or Ixon emitter is implied.
+-/
+
+public section
+
+namespace Ix.Compile.SourceElab
+
+open Lean Elab Command Term
+
+private meta def decodePrefix (modes : Syntax) : TermElabM Ixon.BinderContract := do
+  let parts := modes[0].getArgs
+  let mut uses := Ixon.Uses.many
+  let mut owned := Ixon.Owned.shared
+  let mut locality := Ixon.Locality.unrestricted
+  let mut hasUses := false
+  for i in [:parts.size] do
+    if i > 0 then
+      if let some stop := parts[i - 1]!.getTailPos? then
+        if let some start := parts[i]!.getPos? then
+          unless start == stop do
+            throwErrorAt parts[i]! "binder annotation components must be adjacent"
+    let atom := parts[i]![0]
+    if atom.isAtom && atom.getAtomVal == "!" then
+      if owned == .unique then throwErrorAt atom "duplicate ownership annotation"
+      owned := .unique
+    else if atom.isAtom && atom.getAtomVal == "~" then
+      if locality == .local then throwErrorAt atom "duplicate locality annotation"
+      locality := .local
+    else
+      if hasUses then throwErrorAt atom "duplicate usage annotation"
+      uses ← if atom.isAtom && atom.getAtomVal == "&" then pure .affine else
+        match atom.isNatLit? with
+        | some 0 => pure .erased
+        | some 1 => pure .linear
+        | _ => throwErrorAt atom "binder usage must be 0, 1, or &"
+      hasUses := true
+  return ⟨uses, ⟨owned, locality⟩⟩
+
+-- Numeric expansion target avoids carrying parser-specific mode syntax into
+-- stored annotations. Result code 4 denotes an absent result annotation.
+syntax (name := annotatedType) "__ix_binder% " num ident num num num "(" term ")" : term
+
+private meta def sourceOrigin (stx : Syntax) : Nat :=
+  (stx.getPos?.map (·.byteIdx)).getD 0
+
+private meta def markTypeSyntax (ref : Syntax) (name : Ident) (type : Term)
+    (contract : Ixon.BinderContract) (result : Option Ixon.ValueContract := none)
+    (kind : Ixon.LetKind := .value) : TermElabM Term := do
+  let origin : NumLit := ⟨Syntax.mkNumLit (toString (sourceOrigin ref))⟩
+  let input : NumLit := ⟨Syntax.mkNumLit (toString contract.toBits.toNat)⟩
+  let output : NumLit := ⟨Syntax.mkNumLit (toString ((result.map (·.toBits.toNat)).getD 4))⟩
+  let kind : NumLit := ⟨Syntax.mkNumLit (if kind == .borrowShared then "1" else "0")⟩
+  `(__ix_binder% $origin:num $name:ident $input:num $output:num $kind:num ($type))
+
+@[term_elab annotatedType]
+meta def elabAnnotatedType : TermElab := fun stx expectedType? => do
+  let some origin := stx[1].isNatLit? | throwErrorAt stx "invalid source annotation origin"
+  let some input := stx[3].isNatLit? | throwErrorAt stx "invalid source input contract"
+  if input > 15 then throwErrorAt stx "invalid source input contract"
+  let some contract := Ixon.BinderContract.ofBits? input.toUInt8
+    | throwErrorAt stx "invalid source input contract"
+  let some output := stx[4].isNatLit? | throwErrorAt stx "invalid source result contract"
+  let result ← if output == 4 then pure none else do
+    if output > 3 then throwErrorAt stx "invalid source result contract"
+    let some value := Ixon.ValueContract.ofBits? output.toUInt8
+      | throwErrorAt stx "invalid source result contract"
+    pure (some value)
+  let kind ← match stx[5].isNatLit? with
+    | some 0 => pure Ixon.LetKind.value
+    | some 1 => pure Ixon.LetKind.borrowShared
+    | _ => throwErrorAt stx "invalid source let kind"
+  let annotation : BinderAnnotation := {
+    origin, binder := stx[2].getId, uses := contract.uses, value := contract.value
+    result, letKind := kind }
+  let type ← elabTerm stx[7] expectedType?
+  match annotation.attach type with
+  | .ok expr => return expr
+  | .error error => throwErrorAt stx "{error}"
+
+private meta def isAnnotatedBinder (binder : Syntax) : Bool :=
+  binder.isOfKind ``SourceSyntax.explicitBinder ||
+  binder.isOfKind ``SourceSyntax.implicitBinder ||
+  binder.isOfKind ``SourceSyntax.strictImplicitBinder ||
+  binder.isOfKind ``SourceSyntax.instanceBinder
+
+/-- Split a multi-name final binder before attaching the result contract.
+The result belongs to the last arrow, not to every arrow in that group. -/
+private meta def rewriteBinder (binder : Syntax)
+    (result : Option Ixon.ValueContract := none) : TermElabM (Array Syntax) := do
+  let kind := binder.getKind
+  if isAnnotatedBinder binder then
+    let name : Ident := ⟨binder[2]⟩
+    let contract ← decodePrefix binder[1]
+    let marked ← markTypeSyntax binder name ⟨binder[4]⟩ contract result
+    let rewritten ← if kind == ``SourceSyntax.explicitBinder then
+        `(bracketedBinder| ($name:ident : $marked))
+      else if kind == ``SourceSyntax.implicitBinder then
+        `(bracketedBinder| {$name:ident : $marked})
+      else if kind == ``SourceSyntax.strictImplicitBinder then
+        `(bracketedBinder| ⦃$name:ident : $marked⦄)
+      else
+        `(bracketedBinder| [$name:ident : $marked])
+    return #[rewritten.raw]
+  if result.isNone then return #[binder]
+  if binder.isIdent then
+    let name : Ident := ⟨binder⟩
+    let marked ← markTypeSyntax binder name ⟨mkHole binder⟩ .many result
+    return #[(← `(bracketedBinder| ($name:ident : $marked))).raw]
+  if kind == ``Parser.Term.explicitBinder || kind == ``Parser.Term.implicitBinder ||
+      kind == ``Parser.Term.strictImplicitBinder then
+    if kind == ``Parser.Term.explicitBinder && !binder[3].isNone then
+      throwErrorAt binder "put the result contract on an explicit arrow when the final binder has a default value"
+    let names := binder[1].getArgs
+    let some last := names.back? | throwErrorAt binder "missing result-bearing binder"
+    unless last.isIdent do throwErrorAt last "a result-bearing binder must have a name"
+    let type : Syntax := if binder[2].getNumArgs == 0 then (mkHole binder).raw else binder[2][1]
+    let marked ← markTypeSyntax last ⟨last⟩ ⟨type⟩ .many result
+    let typeSpec := mkNullNode #[mkAtom ":", marked.raw]
+    let final := binder.setArg 1 (mkNullNode #[last]) |>.setArg 2 typeSpec
+    if names.size == 1 then return #[final]
+    return #[binder.setArg 1 (mkNullNode names.pop), final]
+  if kind == ``Parser.Term.instBinder then
+    let name ← if binder[1].isNone then mkFreshIdent binder else pure ⟨binder[1][0]⟩
+    let marked ← markTypeSyntax binder name ⟨binder[2]⟩ .many result
+    return #[(← `(bracketedBinder| [$name:ident : $marked])).raw]
+  throwErrorAt binder "unsupported result-bearing binder"
+
+private meta def rewriteBinders (binders : Array Syntax)
+    (result : Option Ixon.ValueContract := none) : TermElabM (Array Syntax) := do
+  if binders.isEmpty && result.isSome then
+    throwError "a result contract requires a function arrow"
+  let mut rewritten := #[]
+  for i in [:binders.size] do
+    let output := if i + 1 == binders.size then result else none
+    rewritten := rewritten ++ (← rewriteBinder binders[i]! output)
+  return rewritten
+
+private meta def decodeResult (stx : Syntax) : TermElabM Ixon.ValueContract := do
+  return (← decodePrefix stx).value
+
+@[term_elab Ix.Compile.SourceSyntax.annotatedFun]
+meta def elabAnnotatedFun : TermElab := fun stx expectedType? => do
+  let signature := stx[1]
+  let binders ← rewriteBinders signature[0].getArgs
+  let basic := mkNode ``Parser.Term.basicFun #[mkNullNode binders, signature[1], stx[2], stx[3]]
+  elabTerm (mkNode ``Parser.Term.fun #[stx[0], basic]) expectedType?
+
+@[term_elab Ix.Compile.SourceSyntax.annotatedForall]
+meta def elabAnnotatedForall : TermElab := fun stx expectedType? => do
+  let signature := stx[1]
+  let result : Option Ixon.ValueContract ← if signature[3].isNone then pure none else
+    some <$> decodeResult signature[3][0]
+  let binders ← rewriteBinders signature[0].getArgs result
+  let ordinary := mkNode ``Parser.Term.forall
+    #[stx[0], mkNullNode binders, signature[1], signature[2], stx[2]]
+  elabTerm ordinary expectedType?
+
+@[term_elab Ix.Compile.SourceSyntax.annotatedDepArrow]
+meta def elabAnnotatedDepArrow : TermElab := fun stx _ => do
+  let signature := stx[0]
+  let result : Option Ixon.ValueContract ← if signature[2].isNone then pure none else
+    some <$> decodeResult signature[2][0]
+  let binders ← rewriteBinder signature[0] result
+  elabBinders binders fun xs => do
+    Lean.Meta.mkForallFVars xs (← elabType stx[1])
+
+@[term_elab Ix.Compile.SourceSyntax.annotatedArrow]
+meta def elabAnnotatedArrow : TermElab := fun stx _ => do
+  let result ← decodeResult stx[2]
+  let domain ← elabType stx[0]
+  let range ← elabType stx[3]
+  let name ← mkFreshUserName `_argument
+  let annotation : BinderAnnotation := {
+    origin := sourceOrigin stx, binder := name, uses := .many, value := .shared
+    result := some result }
+  let domain ← match annotation.attach domain with
+    | .ok domain => pure domain
+    | .error error => throwErrorAt stx "{error}"
+  return .forallE name domain range .default
+
+@[term_elab Ix.Compile.SourceSyntax.annotatedLet]
+meta def elabAnnotatedLet : TermElab := fun stx expectedType? => do
+  let binder := stx[2]
+  let name : Ident := ⟨binder[2]⟩
+  let contract ← decodePrefix binder[1]
+  let kind := if stx[1].isNone then Ixon.LetKind.value else .borrowShared
+  if kind == .borrowShared && contract.value != .localShared then
+    throwErrorAt binder "a shared borrow requires a shared local view (~)"
+  let marked ← markTypeSyntax binder name ⟨binder[4]⟩ contract none kind
+  elabLetDeclAux name.raw #[] marked.raw stx[4] stx[6] expectedType? {}
+
+@[command_elab Ix.Compile.SourceSyntax.declaration]
+meta def elabDeclaration : CommandElab := fun stx => do
+  let definition := stx[1]
+  let signature := definition[2]
+  let annotatedResult := signature[1].isOfKind ``SourceSyntax.resultType
+  let result ← if annotatedResult then liftTermElabM do
+      return some (← decodeResult signature[1][1])
+    else pure none
+  let binders ← liftTermElabM (rewriteBinders signature[0].getArgs result)
+  let typeSpec := if annotatedResult then
+      mkNullNode #[mkNode ``Parser.Term.typeSpec #[signature[1][0], signature[1][2]]]
+    else signature[1]
+  let signature := signature.setKind ``Parser.Command.optDeclSig
+    |>.setArg 0 (mkNullNode binders) |>.setArg 1 typeSpec
+  let definition := definition.setKind ``Parser.Command.definition |>.setArg 2 signature
+  let ordinary := stx.setKind ``Parser.Command.declaration |>.setArg 1 definition
+  elabCommand ordinary
+  let name ← resolveGlobalConstNoOverload definition[1][0]
+  let source ← getConstInfo name
+  if sourceHasAnnotations source then
+    let contract ← match SourceContract.fromAnnotations source with
+      | .ok contract => pure contract
+      | .error error => throwErrorAt stx "{error}"
+    let env ← match registerSourceContract (← getEnv) contract with
+      | .ok env => pure env
+      | .error error => throwErrorAt stx "{error}"
+    setEnv env
+
+attribute [command_parser 2000] Ix.Compile.SourceSyntax.declaration
+
+end Ix.Compile.SourceElab
+
+end
diff --git a/Ix/Compile/SourceContract/Marker.lean b/Ix/Compile/SourceContract/Marker.lean
new file mode 100644
index 000000000..94140bb5a
--- /dev/null
+++ b/Ix/Compile/SourceContract/Marker.lean
@@ -0,0 +1,113 @@
+module
+
+public import Ix.Compile.SourceContract.Basic
+public import Lean.Util.FindExpr
+
+/-!
+# Source annotation markers
+
+These markers bind frontend intent to elaborated binder domains. They are not
+an Ixon encoding or optional optimization hints. An emitter that cannot consume
+them must reject the source before it erases metadata.
+-/
+
+public section
+
+namespace Ix.Compile
+
+def sourceAnnotationKey : Lean.Name := `ix.source.binder
+
+structure BinderAnnotation where
+  origin : Nat
+  binder : Lean.Name
+  uses : Ixon.Uses
+  value : Ixon.ValueContract
+  result : Option Ixon.ValueContract := none
+  letKind : Ixon.LetKind := .value
+  deriving BEq, Repr, Inhabited
+
+def hasSourceAnnotation (data : Lean.MData) : Bool :=
+  data.entries.any fun (key, _) => sourceAnnotationKey.isPrefixOf key
+
+def BinderAnnotation.toMetadata (annotation : BinderAnnotation) : Lean.MData := Id.run do
+  let mut data := ({} : Lean.MData)
+    |>.setNat sourceAnnotationKey 3
+    |>.setNat `ix.source.binder.origin annotation.origin
+    |>.setName `ix.source.binder.name annotation.binder
+    |>.setNat `ix.source.binder.contract (Ixon.BinderContract.toBits ⟨annotation.uses, annotation.value⟩).toNat
+    |>.setNat `ix.source.binder.letKind (match annotation.letKind with | .value => 0 | .borrowShared => 1)
+  if let some result := annotation.result then
+    data := data.setNat `ix.source.binder.result result.toBits.toNat
+  return data
+
+/-- Strictly decode the reserved namespace. Other metadata, including Lean's
+native borrow hint, is orthogonal. Unknown versions, keys, and duplicate keys
+are errors, including when the version marker itself is missing. -/
+def BinderAnnotation.ofMetadata? (data : Lean.MData) : Except String (Option BinderAnnotation) := do
+  if !hasSourceAnnotation data then return none
+  let keys := #[sourceAnnotationKey, `ix.source.binder.origin, `ix.source.binder.name,
+    `ix.source.binder.contract, `ix.source.binder.result, `ix.source.binder.letKind]
+  let mut seen : Std.HashSet Lean.Name := {}
+  for (key, _) in data.entries do
+    if sourceAnnotationKey.isPrefixOf key then
+      if !keys.contains key then throw s!"unknown source annotation field {key}"
+      if seen.contains key then throw s!"duplicate source annotation field {key}"
+      seen := seen.insert key
+  let some (.ofNat 3) := data.find sourceAnnotationKey
+    | throw "unsupported or missing source annotation version"
+  let some (.ofNat origin) := data.find `ix.source.binder.origin
+    | throw "missing source annotation origin"
+  let some (.ofName binder) := data.find `ix.source.binder.name
+    | throw "missing source binder name"
+  let some (.ofNat bits) := data.find `ix.source.binder.contract
+    | throw "missing source binder contract"
+  if bits > 15 then throw "invalid source binder contract"
+  let some contract := Ixon.BinderContract.ofBits? bits.toUInt8
+    | throw "invalid source binder contract"
+  let result ← match data.find `ix.source.binder.result with
+    | none => pure none
+    | some (.ofNat bits) => do
+      if bits > 3 then throw "invalid source result contract"
+      let some result := Ixon.ValueContract.ofBits? bits.toUInt8
+        | throw "invalid source result contract"
+      pure (some result)
+    | _ => throw "invalid source result contract"
+  let letKind ← match data.find `ix.source.binder.letKind with
+    | some (.ofNat 0) => pure Ixon.LetKind.value
+    | some (.ofNat 1) => pure Ixon.LetKind.borrowShared
+    | _ => throw "invalid source let kind"
+  return some { origin, binder, uses := contract.uses, value := contract.value, result, letKind }
+
+/-- Read only the domain's outer metadata chain, without reducing its type. -/
+def binderAnnotation? : Lean.Expr → Except String (Option BinderAnnotation)
+  | .mdata data inner => do
+    let outer ← BinderAnnotation.ofMetadata? data
+    let nested ← binderAnnotation? inner
+    match outer, nested with
+    | some _, some _ => throw "multiple source annotations on one binder domain"
+    | some annotation, none | none, some annotation => return some annotation
+    | none, none => return none
+  | _ => .ok none
+
+/-- Preserve existing outer metadata frames when adding the source marker.
+Lean recognizes native borrow annotations only as a singleton outer frame, so
+combining their entries with this marker would hide the native hint. -/
+def BinderAnnotation.attach (annotation : BinderAnnotation) (type : Lean.Expr) :
+    Except String Lean.Expr := do
+  if (← binderAnnotation? type).isSome then throw "source binder is already annotated"
+  let data := annotation.toMetadata
+  let rec insert : Lean.Expr → Lean.Expr
+    | .mdata native inner => .mdata native (insert inner)
+    | inner => .mdata data inner
+  return insert type
+
+/-- Use Lean's shared-expression search rather than revisiting every occurrence
+of an unannotated shared subtree during the production preflight. -/
+def exprHasSourceAnnotations (expr : Lean.Expr) : Bool :=
+  (expr.find? fun
+    | .mdata data _ => hasSourceAnnotation data
+    | _ => false).isSome
+
+end Ix.Compile
+
+end
diff --git a/Ix/Compile/SourceContract/Registry.lean b/Ix/Compile/SourceContract/Registry.lean
new file mode 100644
index 000000000..d22e8820f
--- /dev/null
+++ b/Ix/Compile/SourceContract/Registry.lean
@@ -0,0 +1,91 @@
+module
+
+public import Ix.Compile.SourceContract.Resolve
+public import Lean.EnvExtension
+
+/-!
+# Persistent source-contract registration
+
+The extension is an elaboration convenience. Export produces the explicit pure
+CompileInput consumed by validation; the extension itself is never a compiler
+input. Keep imported registration patches instead of overwriting by declaration,
+so conflicting contracts from different modules are diagnosed during export.
+-/
+
+public section
+
+namespace Ix.Compile
+
+abbrev ContractRegistry := Std.HashMap Lean.Name (Array SourceContract)
+
+private def addContract (state : ContractRegistry) (entry : SourceContract) : ContractRegistry :=
+  state.insert entry.source.name ((state[entry.source.name]?.getD #[]).push entry)
+
+initialize sourceContractExtension :
+    Lean.SimplePersistentEnvExtension SourceContract ContractRegistry ←
+  Lean.registerSimplePersistentEnvExtension {
+    addEntryFn := addContract
+    addImportedFn := Lean.mkStateFromImportedEntries addContract {} }
+
+abbrev MeasureRegistry := Std.HashMap Lean.Name (Array MeasureHint)
+
+private def addMeasure (state : MeasureRegistry) (entry : MeasureHint) : MeasureRegistry :=
+  state.insert entry.source.name ((state[entry.source.name]?.getD #[]).push entry)
+
+initialize sourceMeasureExtension :
+    Lean.SimplePersistentEnvExtension MeasureHint MeasureRegistry ←
+  Lean.registerSimplePersistentEnvExtension {
+    addEntryFn := addMeasure
+    addImportedFn := Lean.mkStateFromImportedEntries addMeasure {} }
+
+private def mergeContracts (actual : Lean.ConstantInfo) (patches : Array SourceContract) :
+    Except SourceContractError SourceContract := do
+  let mut binders := #[]
+  for patch in patches do
+    if patch.source != actual then throw (.staleSource patch.source.name)
+    binders := binders ++ patch.binders
+  return { source := actual, binders }
+
+/-- Register a checked patch. Disjoint patches accumulate; duplicate or
+conflicting occurrences fail even when their requested modes are identical. -/
+def registerSourceContract (env : Lean.Environment) (contract : SourceContract) :
+    Except SourceContractError Lean.Environment := do
+  let name := contract.source.name
+  let some actual := env.find? name | throw (.missingDeclaration name)
+  let previous := (sourceContractExtension.getState env)[name]?.getD #[]
+  let merged ← mergeContracts actual (previous.push contract)
+  let _ ← merged.resolve actual
+  return sourceContractExtension.addEntry env contract
+
+def registerMeasureHint (env : Lean.Environment) (hint : MeasureHint) :
+    Except SourceContractError Lean.Environment := do
+  let name := hint.source.name
+  let some actual := env.find? name | throw (.missingDeclaration name)
+  let previous := (sourceMeasureExtension.getState env)[name]?.getD #[]
+  if !previous.isEmpty then throw (.duplicateMeasure name)
+  let _ ← hint.resolve actual
+  return sourceMeasureExtension.addEntry env hint
+
+/-- Export the selected declarations' loaded registrations, including imports.
+Unselected declarations' annotations are outside this input. Dangling, stale,
+or conflicting records in the selected input are rejected by the pure checker. -/
+def compileInputFromEnv (env : Lean.Environment)
+    (constants : List (Lean.Name × Lean.ConstantInfo)) : Except SourceContractError CompileInput := do
+  let registry := sourceContractExtension.getState env
+  let hints := sourceMeasureExtension.getState env
+  let mut contracts := #[]
+  let mut measureHints := #[]
+  for (name, actual) in constants do
+    if let some patches := registry[name]? then
+      contracts := contracts.push (← mergeContracts actual patches)
+    else if sourceHasAnnotations actual then
+      contracts := contracts.push (← SourceContract.fromAnnotations actual)
+    measureHints := measureHints ++ (hints[name]?.getD #[])
+  let input := { constants, contracts, measureHints : CompileInput }
+  let _ ← input.resolve
+  return input
+
+end Ix.Compile
+
+end
+
diff --git a/Ix/Compile/SourceContract/Resolve.lean b/Ix/Compile/SourceContract/Resolve.lean
new file mode 100644
index 000000000..18382928a
--- /dev/null
+++ b/Ix/Compile/SourceContract/Resolve.lean
@@ -0,0 +1,326 @@
+module
+
+public import Ix.Compile.SourceContract.Marker
+
+public section
+
+namespace Ix.Compile
+
+/-- Unlike ConstantInfo.value?'s default, include opaque declaration bodies. -/
+def sourceBody? : Lean.ConstantInfo → Option Lean.Expr
+  | .defnInfo info => some info.value
+  | .thmInfo info => some info.value
+  | .opaqueInfo info => some info.value
+  | _ => none
+
+def sourceRoot? (source : Lean.ConstantInfo) : SourceRoot → Option Lean.Expr
+  | .type => some source.type
+  | .body => sourceBody? source
+
+def sourceHasAnnotations (source : Lean.ConstantInfo) : Bool :=
+  exprHasSourceAnnotations source.type ||
+    ((sourceBody? source).map exprHasSourceAnnotations).getD false ||
+    match source with
+    | .recInfo info => info.rules.any (exprHasSourceAnnotations ·.rhs)
+    | _ => false
+
+def sourceChild? : Lean.Expr → SourceStep → Option Lean.Expr
+  | .app fn _, .appFn => some fn
+  | .app _ arg, .appArg => some arg
+  | .lam _ type _ _, .binderType | .forallE _ type _ _, .binderType => some type
+  | .lam _ _ body _, .binderBody | .forallE _ _ body _, .binderBody => some body
+  | .letE _ type _ _ _, .letType => some type
+  | .letE _ _ value _ _, .letValue => some value
+  | .letE _ _ _ body _, .letBody => some body
+  | .mdata _ inner, .metadata => some inner
+  | .proj _ _ value, .projection => some value
+  | _, _ => none
+
+@[expose] def sourceAtPath? (expr : Lean.Expr) : List SourceStep → Option Lean.Expr
+  | [] => some expr
+  | step :: rest => do sourceAtPath? (← sourceChild? expr step) rest
+
+def sourceAtSite? (source : Lean.ConstantInfo) (site : BinderSite) : Option Lean.Expr := do
+  sourceAtPath? (← sourceRoot? source site.root) site.path
+
+@[simp] theorem sourceAtPath?_nil (expr : Lean.Expr) :
+    sourceAtPath? expr [] = some expr := rfl
+
+/-- Only metadata is transparent to telescope selection. No beta/let reduction,
+typeclass inference, or source telescope permutation happens at this boundary. -/
+def telescopePaths (kind : SourceBinderKind) (expr : Lean.Expr)
+    (path : List SourceStep := []) : List (List SourceStep × Lean.Name) :=
+  match expr with
+  | .mdata _ inner => telescopePaths kind inner (path ++ [.metadata])
+  | .lam name _ body _ =>
+    if kind == .lam then
+      (path, name) :: telescopePaths kind body (path ++ [.binderBody])
+    else []
+  | .forallE name _ body _ =>
+    if kind == .all then
+      (path, name) :: telescopePaths kind body (path ++ [.binderBody])
+    else []
+  | _ => []
+
+def sourceTelescope (source : Lean.ConstantInfo) (root : SourceRoot) :
+    Array (BinderSite × Lean.Name) :=
+  match sourceRoot? source root with
+  | none => #[]
+  | some expr =>
+    let kind := match root with | .type => .all | .body => .lam
+    ((telescopePaths kind expr).map fun (path, name) => (⟨root, path⟩, name)).toArray
+
+def resolveBinderSelector (source : Lean.ConstantInfo) (selector : BinderSelector) :
+    Except SourceContractError Nat := do
+  let telescope := sourceTelescope source .type
+  match selector with
+  | .position index =>
+    if index < telescope.size then return index
+    throw (.argumentOutOfRange source.name index)
+  | .name name =>
+    let indices := (List.range telescope.size).filter fun i => telescope[i]!.2 == name
+    match indices with
+    | [] => throw (.unknownBinder source.name name)
+    | [index] => return index
+    | _ => throw (.ambiguousBinder source.name name)
+
+/-- Expand declaration shorthand into separate type/body occurrences. The
+result never marks earlier or later curried arrow results unique implicitly. -/
+def SourceContract.ofTelescope (source : Lean.ConstantInfo)
+    (contracts : Array TelescopeContract) :
+    Except SourceContractError SourceContract := do
+  let types := sourceTelescope source .type
+  let bodies := sourceTelescope source .body
+  let mut binders := #[]
+  for contract in contracts do
+    let index ← resolveBinderSelector source contract.binder
+    let some (typeSite, _) := types[index]?
+      | throw (.argumentOutOfRange source.name index)
+    binders := binders.push {
+      site := typeSite, uses := contract.uses, result := contract.result
+      value := contract.value, letKind := contract.letKind }
+    if (sourceBody? source).isSome then
+      let some (bodySite, _) := bodies[index]?
+        | throw (.missingBodyBinder source.name index)
+      binders := binders.push {
+        site := bodySite, uses := contract.uses, value := contract.value, letKind := contract.letKind }
+  return { source, binders }
+
+def resolveBinderContract (source : Lean.ConstantInfo) (contract : BinderContract) :
+    Except SourceContractError ResolvedBinderContract := do
+  let some expr := sourceAtSite? source contract.site
+    | throw (.invalidSite source.name contract.site)
+  let (kind, name, binderInfo) ← match expr with
+    | .lam name _ _ info => pure (SourceBinderKind.lam, name, info)
+    | .forallE name _ _ info => pure (SourceBinderKind.all, name, info)
+    | .letE name _ _ _ _ => pure (SourceBinderKind.letE, name, Lean.BinderInfo.default)
+    | _ => throw (.expectedBinder source.name contract.site)
+  if kind != .all && contract.result.isSome then
+    throw (.resultOnNonArrow source.name contract.site)
+  if kind != .letE && contract.letKind != .value then
+    throw (.borrowOnNonLet source.name contract.site)
+  if contract.letKind == .borrowShared && contract.value != .localShared then
+    throw (.invalidBorrowView source.name contract.site)
+  return {
+    site := contract.site, kind, name, binderInfo
+    uses := contract.uses, value := contract.value, letKind := contract.letKind
+    result := if kind == .all then some (contract.result.getD .shared) else none }
+
+def ResolvedSourceContract.usesAt (contract : ResolvedSourceContract)
+    (site : BinderSite) : Ixon.Uses :=
+  ((contract.binders.find? fun binder => binder.site == site).map (·.uses)).getD .many
+
+def ResolvedSourceContract.valueAt (contract : ResolvedSourceContract)
+    (site : BinderSite) : Ixon.ValueContract :=
+  ((contract.binders.find? fun binder => binder.site == site).map (·.value)).getD .shared
+
+private structure CollectedAnnotations where
+  binders : Array (BinderSite × BinderAnnotation) := #[]
+  markers : Array (BinderSite × BinderAnnotation) := #[]
+
+private def collectAnnotations (declaration : Lean.Name) (root : SourceRoot)
+    (expr : Lean.Expr) (path : List SourceStep) (acc : CollectedAnnotations) :
+    Except SourceContractError CollectedAnnotations := do
+  let site : BinderSite := ⟨root, path⟩
+  let mut acc := acc
+  match expr with
+  | .lam name type _ _ | .forallE name type _ _ | .letE name type _ _ _ =>
+    let annotation ← (binderAnnotation? type).mapError (.malformedAnnotation declaration site)
+    if let some annotation := annotation then
+      if annotation.binder != name then
+        -- Expected arrow domains can be copied into an alpha-renamed lambda.
+        -- The original marker must already have been validated in the type.
+        let isLambda := match expr with | .lam .. => true | _ => false
+        unless isLambda && root == .body && acc.binders.any (fun (site, original) =>
+            site.root == .type && original == annotation) do
+          throw (.annotationBinderMismatch declaration site annotation.binder name)
+      acc := { acc with binders := acc.binders.push (site, annotation) }
+  | .mdata data _ =>
+    let annotation ← (BinderAnnotation.ofMetadata? data).mapError (.malformedAnnotation declaration site)
+    if let some annotation := annotation then
+      acc := { acc with markers := acc.markers.push (site, annotation) }
+  | _ => pure ()
+  match expr with
+  | .app fn arg =>
+    let next ← collectAnnotations declaration root fn (path ++ [.appFn]) acc
+    collectAnnotations declaration root arg (path ++ [.appArg]) next
+  | .lam _ type body _ | .forallE _ type body _ =>
+    let next ← collectAnnotations declaration root type (path ++ [.binderType]) acc
+    collectAnnotations declaration root body (path ++ [.binderBody]) next
+  | .letE _ type value body _ =>
+    let next ← collectAnnotations declaration root type (path ++ [.letType]) acc
+    let final ← collectAnnotations declaration root value (path ++ [.letValue]) next
+    collectAnnotations declaration root body (path ++ [.letBody]) final
+  | .mdata _ inner => collectAnnotations declaration root inner (path ++ [.metadata]) acc
+  | .proj _ _ value => collectAnnotations declaration root value (path ++ [.projection]) acc
+  | _ => return acc
+
+/-- Recover the explicit source records from elaborated binder-domain markers.
+Repeated copies of a marker outside binder domains can arise during type
+inference. They must agree with the original annotation; they do not annotate
+another binder. A duplicated or renamed binder origin is unsupported. -/
+def SourceContract.fromAnnotations (source : Lean.ConstantInfo) :
+    Except SourceContractError SourceContract := do
+  if let .recInfo info := source then
+    if info.rules.any (exprHasSourceAnnotations ·.rhs) then
+      throw (.annotatedRecursorRule source.name)
+  let acc ← collectAnnotations source.name .type source.type [] {}
+  let acc ← match sourceBody? source with
+    | some body => collectAnnotations source.name .body body [] acc
+    | none => pure acc
+  let mut origins : Std.HashSet (SourceRoot × Nat) := {}
+  let mut binders := #[]
+  for (site, annotation) in acc.binders do
+    let key := (site.root, annotation.origin)
+    if origins.contains key then throw (.duplicateAnnotation source.name site.root annotation.origin)
+    origins := origins.insert key
+    let isArrow := match sourceAtSite? source site with | some (.forallE ..) => true | _ => false
+    if !isArrow && annotation.result.isSome then
+      let copiedFromType := site.root == .body && acc.binders.any fun (other, original) =>
+        other.root == .type && original == annotation
+      unless copiedFromType do throw (.resultOnNonArrow source.name site)
+    binders := binders.push {
+      site, uses := annotation.uses, value := annotation.value
+      result := if isArrow then annotation.result else none, letKind := annotation.letKind }
+  for (site, marker) in acc.markers do
+    let some (_, annotation) := acc.binders.find? fun (binderSite, annotation) =>
+        binderSite.root == site.root && annotation.origin == marker.origin
+      | throw (.misplacedAnnotation source.name site)
+    if marker != annotation then throw (.conflictingAnnotation source.name site)
+  -- Lean retains binder-domain metadata in the declaration type while erasing
+  -- it from generated lambdas. Expand that one header to both occurrences,
+  -- requiring an unchanged direct telescope; do not infer a rewrite mapping.
+  if (sourceBody? source).isSome then
+    let types := sourceTelescope source .type
+    let bodies := sourceTelescope source .body
+    for index in [:types.size] do
+      let typeSite := types[index]!.1
+      if let some annotation := binders.find? (·.site == typeSite) then
+        let some (bodySite, _) := bodies[index]?
+          | throw (.missingBodyBinder source.name index)
+        let some (.forallE typeName typeDomain _ typeInfo) := sourceAtSite? source typeSite
+          | throw (.expectedBinder source.name typeSite)
+        let some (.lam bodyName bodyDomain _ bodyInfo) := sourceAtSite? source bodySite
+          | throw (.expectedBinder source.name bodySite)
+        if typeInfo != bodyInfo ||
+            typeDomain.consumeMData != bodyDomain.consumeMData then
+          throw (.annotationBinderMismatch source.name bodySite typeName bodyName)
+        if !binders.any (·.site == bodySite) then
+          binders := binders.push { annotation with site := bodySite, result := none }
+  return { source, binders }
+
+/-- Check direct declaration telescope correspondence. This is a structural
+preflight, not inference of nested function types or proof of resource validity.
+A body whose telescope needs normalization is explicitly unsupported when a
+contract addresses an unmatched declaration arrow. -/
+def checkTelescopeConsistency (contract : ResolvedSourceContract) :
+    Except SourceContractError Unit := do
+  let types := sourceTelescope contract.source .type
+  let bodies := sourceTelescope contract.source .body
+  if (sourceBody? contract.source).isNone then return
+  for index in [:max types.size bodies.size] do
+    match types[index]?, bodies[index]? with
+    | some (typeSite, _), some (bodySite, _) =>
+      let typeUses := contract.usesAt typeSite
+      let bodyUses := contract.usesAt bodySite
+      if typeUses != bodyUses then
+        throw (.inconsistentTelescope contract.source.name index typeUses bodyUses)
+      let typeValue := contract.valueAt typeSite
+      let bodyValue := contract.valueAt bodySite
+      if typeValue != bodyValue then
+        throw (.inconsistentValue contract.source.name index typeValue bodyValue)
+    | some (site, _), none | none, some (site, _) =>
+      if contract.binders.any (fun binder => binder.site == site) then
+        throw (.missingBodyBinder contract.source.name index)
+    | none, none => pure ()
+
+/-- Validate source binding and occurrence annotations. Sort sites so declaration
+annotation order cannot become an accidental cache or serialization input. -/
+def SourceContract.resolve (contract : SourceContract) (actual : Lean.ConstantInfo) :
+    Except SourceContractError ResolvedSourceContract := do
+  -- Ix.Common supplies derived structural equality for the complete source,
+  -- including metadata and BinderInfo. Do not substitute Expr's hash equality.
+  if contract.source != actual then throw (.staleSource contract.source.name)
+  if sourceHasAnnotations actual then
+    let expected ← SourceContract.fromAnnotations actual
+    for annotation in expected.binders do
+      let some supplied := contract.binders.find? (·.site == annotation.site)
+        | throw (.missingAnnotation actual.name annotation.site)
+      if supplied != annotation then
+        throw (.conflictingAnnotation actual.name annotation.site)
+  let mut seen : Std.HashSet BinderSite := {}
+  let mut binders := #[]
+  for binder in contract.binders do
+    if seen.contains binder.site then throw (.duplicateSite actual.name binder.site)
+    seen := seen.insert binder.site
+    binders := binders.push (← resolveBinderContract actual binder)
+  binders := binders.qsort fun a b => compare a.site b.site == .lt
+  let result : ResolvedSourceContract := { source := actual, binders }
+  checkTelescopeConsistency result
+  return result
+
+/-- Resolve a nonsemantic measure proposal independently of binder contracts. -/
+def MeasureHint.resolve (hint : MeasureHint) (actual : Lean.ConstantInfo) :
+    Except SourceContractError ResolvedMeasureHint := do
+  let name := hint.source.name
+  if hint.source != actual then throw (.staleSource name)
+  let argument ← resolveBinderSelector actual hint.argument
+  let some (site, _) := (sourceTelescope actual .type)[argument]?
+    | throw (.argumentOutOfRange name argument)
+  if hint.fixedStep == some 0 then throw (.zeroFixedStep name)
+  return ⟨actual, argument, site, hint.fixedStep⟩
+
+/-- Resolve a complete input without consulting a Lean environment. The explicit
+registry is checked before a caller may canonicalize or merge source terms. -/
+def CompileInput.resolve (input : CompileInput) :
+    Except SourceContractError ResolvedCompileInput := do
+  let mut selected : Std.HashMap Lean.Name Lean.ConstantInfo := {}
+  for (name, source) in input.constants do
+    if name != source.name then throw (.declarationNameMismatch name source.name)
+    if selected.contains name then throw (.duplicateDeclaration name)
+    selected := selected.insert name source
+  let mut seen : Std.HashSet Lean.Name := {}
+  let mut contracts := #[]
+  for contract in input.contracts do
+    let name := contract.source.name
+    if seen.contains name then throw (.duplicateContract name)
+    seen := seen.insert name
+    let some actual := selected[name]? | throw (.missingDeclaration name)
+    contracts := contracts.push (← contract.resolve actual)
+  for (name, source) in input.constants do
+    if sourceHasAnnotations source && !seen.contains name then throw (.missingContract name)
+  contracts := contracts.qsort fun a b => a.source.name.cmp b.source.name == .lt
+  let mut seenHints : Std.HashSet Lean.Name := {}
+  let mut measureHints := #[]
+  for hint in input.measureHints do
+    let name := hint.source.name
+    if seenHints.contains name then throw (.duplicateMeasure name)
+    seenHints := seenHints.insert name
+    let some actual := selected[name]? | throw (.missingDeclaration name)
+    measureHints := measureHints.push (← hint.resolve actual)
+  measureHints := measureHints.qsort fun a b => a.source.name.cmp b.source.name == .lt
+  return { constants := input.constants, contracts, measureHints }
+
+end Ix.Compile
+
+end
diff --git a/Ix/Compile/SourceContract/Syntax.lean b/Ix/Compile/SourceContract/Syntax.lean
new file mode 100644
index 000000000..c5d87da73
--- /dev/null
+++ b/Ix/Compile/SourceContract/Syntax.lean
@@ -0,0 +1,114 @@
+module
+
+public import Lean
+
+/-!
+# Binder-prefix grammar
+
+The declaration parser activates only when a header has an annotated binder.
+The elaborator is loaded by importing SourceContract.Elab.
+-/
+
+public meta section
+
+namespace Ix.Compile.SourceSyntax
+
+open Lean Parser
+
+@[expose] def prefixAtom := leading_parser
+  rawCh '!' (trailingWs := true) <|> rawCh '~' (trailingWs := true) <|> numLit <|> "&"
+
+@[expose] def binderPrefix := leading_parser many1 prefixAtom
+
+@[expose] def explicitBinder := leading_parser
+  "(" >> binderPrefix >> checkWsBefore "space required before the binder name" >>
+  ident >> " : " >> termParser >> ")"
+
+@[expose] def implicitBinder := leading_parser
+  "{" >> binderPrefix >> checkWsBefore "space required before the binder name" >>
+  ident >> " : " >> termParser >> "}"
+
+@[expose] def strictImplicitBinder := leading_parser
+  Term.strictImplicitLeftBracket >> binderPrefix >>
+  checkWsBefore "space required before the binder name" >>
+  ident >> " : " >> termParser >> Term.strictImplicitRightBracket
+
+@[expose] def instanceBinder := leading_parser
+  "[" >> binderPrefix >> checkWsBefore "space required before the binder name" >>
+  ident >> " : " >> termParser >> "]"
+
+@[expose] def annotatedBinder :=
+  explicitBinder <|> strictImplicitBinder <|> implicitBinder <|> instanceBinder
+
+@[expose] def valueAtom := leading_parser
+  rawCh '!' (trailingWs := true) <|> rawCh '~' (trailingWs := true)
+
+@[expose] def valuePrefix := leading_parser many1 valueAtom
+
+@[expose] def resultType := leading_parser " : " >> valuePrefix >> termParser
+
+@[expose] def declarationSignature := leading_parser
+  many (ppSpace >> (atomic annotatedBinder <|> Term.bracketedBinder <|> Term.binderIdent)) >>
+    (atomic resultType <|> Term.optType)
+
+@[expose] def hasAnnotatedBinder (signature : Syntax) : Bool :=
+  signature[0].getArgs.any fun binder =>
+    binder.isOfKind ``explicitBinder || binder.isOfKind ``implicitBinder ||
+    binder.isOfKind ``strictImplicitBinder || binder.isOfKind ``instanceBinder
+
+@[expose] def definition := leading_parser
+  "def " >> Command.declId >> ppIndent declarationSignature >>
+  Command.declVal >> Command.optDefDeriving
+
+@[expose] def declaration := leading_parser Command.declModifiers false >> definition
+
+@[expose] def funSignature := leading_parser
+  many1 (ppSpace >> (atomic annotatedBinder <|> Term.funBinder)) >> Term.optType
+
+@[expose] def annotatedFun := leading_parser:maxPrec
+  unicodeSymbol "λ" "fun" >> funSignature >>
+  checkStackTop hasAnnotatedBinder "annotated function binder" >>
+  unicodeSymbol " ↦" " =>" >> termParser
+
+@[expose] def forallSignature := leading_parser
+  many1 (ppSpace >> (atomic annotatedBinder <|> Term.bracketedBinder <|> Term.binderIdent)) >>
+  Term.optType >> ", " >> optional valuePrefix
+
+@[expose] def hasForallContract (signature : Syntax) : Bool :=
+  hasAnnotatedBinder signature || !signature[3].isNone
+
+@[expose] def annotatedForall := leading_parser:leadPrec
+  unicodeSymbol "∀" "forall" >> forallSignature >>
+  checkStackTop hasForallContract "annotated forall" >> termParser
+
+@[expose] def dependentArrowSignature := leading_parser
+  (atomic annotatedBinder <|> Term.bracketedBinder true) >>
+  unicodeSymbol " → " " -> " >> optional valuePrefix
+
+@[expose] def hasArrowContract (signature : Syntax) : Bool :=
+  let binder := signature[0]
+  binder.isOfKind ``explicitBinder || binder.isOfKind ``implicitBinder ||
+  binder.isOfKind ``strictImplicitBinder || binder.isOfKind ``instanceBinder ||
+  !signature[2].isNone
+
+@[expose] def annotatedDepArrow := leading_parser:25
+  dependentArrowSignature >> checkStackTop hasArrowContract "annotated arrow" >> termParser
+
+@[expose] def annotatedArrow := trailing_parser
+  checkPrec 25 >> unicodeSymbol " → " " -> " >> valuePrefix >> termParser 25
+
+@[expose] def annotatedLet := leading_parser:leadPrec
+  withPosition ("let" >> optional "borrow" >> explicitBinder >> " := " >> termParser) >>
+  Term.optSemicolon termParser
+
+attribute [term_parser 2000] annotatedFun annotatedForall annotatedDepArrow annotatedArrow annotatedLet
+
+-- Compile parser hooks and register syntax kinds without enabling the general
+-- declaration parser in importing modules before its elaborator is available.
+section
+attribute [local command_parser 2000] declaration
+end
+
+end Ix.Compile.SourceSyntax
+
+end
diff --git a/Ix/Compile/SourceContract/Transport.lean b/Ix/Compile/SourceContract/Transport.lean
new file mode 100644
index 000000000..272f40bde
--- /dev/null
+++ b/Ix/Compile/SourceContract/Transport.lean
@@ -0,0 +1,118 @@
+module
+
+public import Ix.Compile.SourceContract.Registry
+public import Ix.SemanticContract
+
+/-! Resolve occurrence contracts against the original source, then decorate
+the corresponding binders before hashing, canonicalization, or sharing. -/
+
+@[expose] public section
+
+namespace Ix.Compile
+
+def ResolvedBinderContract.semantic (binder : ResolvedBinderContract) :
+    Ix.SemanticContract.Contract := {
+  kind := match binder.kind with | .lam => .lam | .all => .all | .letE => .letE
+  binder := ⟨binder.uses, binder.value⟩
+  result := binder.result.getD .shared
+  letKind := binder.letKind }
+
+def decorateExpr (contract : ResolvedSourceContract) (root : SourceRoot)
+    (path : List SourceStep) (expr : Lean.Expr) : Except String Lean.Expr := do
+  let result ← do
+    match expr with
+    | .bvar _ | .sort _ | .const _ _ | .lit _ => pure expr
+    | .fvar _ | .mvar _ => throw "source transport: open elaboration variable"
+    | .app fn arg =>
+      pure <| .app (← decorateExpr contract root (path ++ [.appFn]) fn)
+        (← decorateExpr contract root (path ++ [.appArg]) arg)
+    | .lam name type body info =>
+      pure <| .lam name (← decorateExpr contract root (path ++ [.binderType]) type)
+        (← decorateExpr contract root (path ++ [.binderBody]) body) info
+    | .forallE name type body info =>
+      pure <| .forallE name (← decorateExpr contract root (path ++ [.binderType]) type)
+        (← decorateExpr contract root (path ++ [.binderBody]) body) info
+    | .letE name type value body nonDep =>
+      pure <| .letE name (← decorateExpr contract root (path ++ [.letType]) type)
+        (← decorateExpr contract root (path ++ [.letValue]) value)
+        (← decorateExpr contract root (path ++ [.letBody]) body) nonDep
+    | .proj name field value =>
+      pure <| .proj name field (← decorateExpr contract root (path ++ [.projection]) value)
+    | .mdata data inner =>
+      unless (Ix.SemanticContract.leanFields data).isEmpty do
+        throw "source transport: reserved semantic metadata in unprocessed source"
+      let data : Lean.MData := ⟨data.entries.filter fun (key, _) => !sourceAnnotationKey.isPrefixOf key⟩
+      let inner ← decorateExpr contract root (path ++ [.metadata]) inner
+      pure <| if data.entries.isEmpty then inner else .mdata data inner
+  match contract.binders.find? (·.site == ⟨root, path⟩) with
+  | none => return result
+  | some binder =>
+    let semantic := binder.semantic
+    return if semantic.isOrdinary then result else semantic.attach result
+termination_by sizeOf expr
+
+def ResolvedSourceContract.decorate (contract : ResolvedSourceContract) :
+    Except String Lean.ConstantInfo := do
+  let source := contract.source
+  let type ← decorateExpr contract .type [] source.type
+  match source with
+  | .defnInfo info =>
+    return .defnInfo { info with type, value := ← decorateExpr contract .body [] info.value }
+  | .thmInfo info =>
+    return .thmInfo { info with type, value := ← decorateExpr contract .body [] info.value }
+  | .opaqueInfo info =>
+    return .opaqueInfo { info with type, value := ← decorateExpr contract .body [] info.value }
+  | .axiomInfo info => return .axiomInfo { info with type }
+  | _ => throw s!"source transport: annotated inductive/constructor/recursor transformations are unsupported: {source.name}"
+
+def exprHasSemanticContracts (expr : Lean.Expr) : Bool :=
+  (expr.find? fun
+    | .mdata data _ => !(Ix.SemanticContract.leanFields data).isEmpty
+    | _ => false).isSome
+
+def sourceHasSemanticContracts (source : Lean.ConstantInfo) : Bool :=
+  exprHasSemanticContracts source.type ||
+    ((sourceBody? source).map exprHasSemanticContracts).getD false ||
+    match source with
+    | .recInfo info => info.rules.any (exprHasSemanticContracts ·.rhs)
+    | _ => false
+
+def ResolvedCompileInput.decorate (input : ResolvedCompileInput) :
+    Except String (List (Lean.Name × Lean.ConstantInfo)) := do
+  input.constants.mapM fun (name, source) => do
+    if sourceHasSemanticContracts source then
+      throw s!"source transport: reserved semantic metadata in unprocessed source: {name}"
+    match input.contracts.find? (·.source.name == name) with
+    | none => return (name, source)
+    | some contract => return (name, ← contract.decorate)
+
+/-- Construct an explicit input from binder metadata when no external
+registration table is available (for example, an isolated constant list). -/
+def CompileInput.fromAnnotations (constants : List (Lean.Name × Lean.ConstantInfo)) :
+    Except SourceContractError CompileInput := do
+  let mut contracts := #[]
+  for (_, source) in constants do
+    if sourceHasAnnotations source then
+      contracts := contracts.push (← SourceContract.fromAnnotations source)
+  return { constants, contracts }
+
+/-- Resolve and decorate once, before either compiler sees the source. -/
+def CompileInput.prepare (input : CompileInput) :
+    Except String (List (Lean.Name × Lean.ConstantInfo)) := do
+  let resolved ← input.resolve.mapError toString
+  resolved.decorate
+
+def prepareSourceConstants (constants : List (Lean.Name × Lean.ConstantInfo)) :
+    Except String (List (Lean.Name × Lean.ConstantInfo)) := do
+  let input ← (CompileInput.fromAnnotations constants).mapError toString
+  input.prepare
+
+def prepareRegisteredConstants (env : Lean.Environment)
+    (constants : List (Lean.Name × Lean.ConstantInfo)) :
+    Except String (List (Lean.Name × Lean.ConstantInfo)) := do
+  let input ← (compileInputFromEnv env constants).mapError toString
+  input.prepare
+
+end Ix.Compile
+
+end
diff --git a/Ix/Compile/Verify/Codec.lean b/Ix/Compile/Verify/Codec.lean
index 15c0753f9..dea03362f 100644
--- a/Ix/Compile/Verify/Codec.lean
+++ b/Ix/Compile/Verify/Codec.lean
@@ -2,7 +2,7 @@ import Ix.Ixon
 import Std.Tactic.BVDecide
 
 /-!
-# Proof-visible v2 codecs
+# Proof-visible v3 codecs
 
 These X1 slices make universe serialization kernel-visible end to end.
 `Reads` records exact cursor movement in arbitrary surrounding bytes, while
@@ -45,6 +45,30 @@ theorem Reads.pure (value : α) :
   change (EStateM.pure value) _ = _
   simp [EStateM.pure]
 
+/-- A validated count does not consume bytes and succeeds whenever the
+following canonical payload supplies the required minimum bytes. -/
+theorem Reads.checkCount {getm : Ixon.GetM α} {bytes : ByteArray} {value : α}
+    (count : UInt64) (minBytes : Nat)
+    (hsize : count.toNat * minBytes ≤ bytes.size)
+    (hread : Reads getm bytes value) :
+    Reads (do Ixon.checkCount count minBytes; getm) bytes value := by
+  intro before after
+  have hremaining : ¬ count.toNat * minBytes >
+      (before ++ bytes ++ after).size - before.size := by
+    simp only [ByteArray.size_append]
+    omega
+  have hcheck : Ixon.checkCount count minBytes
+      { idx := before.size, bytes := before ++ bytes ++ after } =
+      .ok () { idx := before.size, bytes := before ++ bytes ++ after } := by
+    unfold Ixon.checkCount
+    change (EStateM.bind EStateM.get _) _ = _
+    simp only [EStateM.bind, EStateM.get]
+    rw [if_neg hremaining]
+    rfl
+  change (EStateM.bind (Ixon.checkCount count minBytes) _) _ = _
+  rw [EStateM.bind, hcheck]
+  exact hread before after
+
 def Writes (putm : Ixon.PutM Unit) (bytes : ByteArray) : Prop :=
   ∀ before, putm.run before = ((), before ++ bytes)
 
@@ -343,7 +367,8 @@ theorem tag2_large_fields (flag byteCount : UInt8)
     let header := (flag <<< 6) ||| 0x20 ||| (byteCount - 1)
     header >>> 6 = flag ∧
       header &&& 0x20 = 0x20 ∧
-      (header &&& 0x1f).toNat + 1 = byteCount.toNat := by
+      (header &&& 0x1f).toNat + 1 = byteCount.toNat ∧
+      (header &&& 0x1f) + 1 = byteCount := by
   rcases uint8_cases4 flag hflag with rfl | rfl | rfl | rfl <;>
     rcases uint8_cases1_8 byteCount hpos hle with
       rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;>
@@ -381,7 +406,7 @@ theorem getTag2_reads_large (flag : UInt8) (size : UInt64)
     simp only [byteCount, hzero, Nat.mul_zero, Nat.pow_zero] at hfit
     omega
   have hcountLe : byteCount.toNat ≤ 8 := u64ByteCount_toNat_le size
-  obtain ⟨hdecodedFlag, hlarge, hdecodedLen⟩ :=
+  obtain ⟨hdecodedFlag, hlarge, hdecodedLen, hwidth⟩ :=
     tag2_large_fields flag byteCount hflag hcountPos hcountLe
   have hdecodedFlag' : header >>> 6 = flag := by
     simpa [header] using hdecodedFlag
@@ -391,15 +416,26 @@ theorem getTag2_reads_large (flag : UInt8) (size : UInt64)
   have hreturn : Reads
       (pure (⟨flag, size⟩ : Ixon.Tag2) : Ixon.GetM Ixon.Tag2)
       ByteArray.empty ⟨flag, size⟩ := Reads.pure _
+  have hcheckedReturn : Reads
+      (do
+        if size < 32 || Ixon.u64ByteCount size != (header &&& 0x1f) + 1 then
+          throw "noncanonical Tag2 integer"
+        return (⟨flag, size⟩ : Ixon.Tag2))
+      ByteArray.empty ⟨flag, size⟩ := by
+    simpa [hsize, hwidth, byteCount, header] using hreturn
   have hafterSize : Reads
       (do
         let decoded ← Ixon.getU64TrimmedLE byteCount.toNat
+        if decoded < 32 || Ixon.u64ByteCount decoded != (header &&& 0x1f) + 1 then
+          throw "noncanonical Tag2 integer"
         return (⟨flag, decoded⟩ : Ixon.Tag2))
       (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by
     simpa [byteCount] using Reads.bind
-      (next := fun decoded : UInt64 =>
-        (pure (⟨flag, decoded⟩ : Ixon.Tag2) : Ixon.GetM Ixon.Tag2))
-      hsizeRead hreturn
+      (next := fun decoded : UInt64 => do
+        if decoded < 32 || Ixon.u64ByteCount decoded != (header &&& 0x1f) + 1 then
+          throw "noncanonical Tag2 integer"
+        return (⟨flag, decoded⟩ : Ixon.Tag2))
+      hsizeRead hcheckedReturn
   have hlargeNe : header &&& 0x20 ≠ 0 := by
     rw [hlarge]
     decide
@@ -414,6 +450,8 @@ theorem getTag2_reads_large (flag : UInt8) (size : UInt64)
           Ixon.getU64TrimmedLE (small.toNat + 1)
         else
           pure small.toUInt64
+        if large && (decodedSize < 32 || Ixon.u64ByteCount decodedSize != small + 1) then
+          throw "noncanonical Tag2 integer"
         return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag2))
       (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by
     simpa [hdecodedFlag', hlargeNe, hdecodedLen'] using hafterSize
@@ -426,6 +464,8 @@ theorem getTag2_reads_large (flag : UInt8) (size : UInt64)
         Ixon.getU64TrimmedLE (small.toNat + 1)
       else
         pure small.toUInt64
+      if large && (decodedSize < 32 || Ixon.u64ByteCount decodedSize != small + 1) then
+        throw "noncanonical Tag2 integer"
       return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag2))
     hheader htail
   simpa [Ixon.getTag2, tag2Bytes, hsize, byteCount, header] using hall
@@ -615,7 +655,8 @@ theorem tag0_large_fields (byteCount : UInt8)
     (hpos : 0 < byteCount.toNat) (hle : byteCount.toNat ≤ 8) :
     let header := 0x80 ||| (byteCount - 1)
     header &&& 0x80 = 0x80 ∧
-      (header &&& 0x7f).toNat + 1 = byteCount.toNat := by
+      (header &&& 0x7f).toNat + 1 = byteCount.toNat ∧
+      (header &&& 0x7f) + 1 = byteCount := by
   rcases uint8_cases1_8 byteCount hpos hle with
     rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;>
     decide
@@ -634,7 +675,7 @@ theorem getTag0_reads_large (size : UInt64) (hsize : ¬ size < 128) :
     simp only [byteCount, hzero, Nat.mul_zero, Nat.pow_zero] at hfit
     omega
   have hcountLe : byteCount.toNat ≤ 8 := u64ByteCount_toNat_le size
-  obtain ⟨hlarge, hdecodedLen⟩ :=
+  obtain ⟨hlarge, hdecodedLen, hwidth⟩ :=
     tag0_large_fields byteCount hcountPos hcountLe
   have hheader : Reads Ixon.getU8 [header].toByteArray header :=
     getU8_reads header
@@ -642,15 +683,26 @@ theorem getTag0_reads_large (size : UInt64) (hsize : ¬ size < 128) :
   have hreturn : Reads
       (pure (⟨size⟩ : Ixon.Tag0) : Ixon.GetM Ixon.Tag0)
       ByteArray.empty ⟨size⟩ := Reads.pure _
+  have hcheckedReturn : Reads
+      (do
+        if size < 128 || Ixon.u64ByteCount size != (header &&& 0x7f) + 1 then
+          throw "noncanonical Tag0 integer"
+        return (⟨size⟩ : Ixon.Tag0))
+      ByteArray.empty ⟨size⟩ := by
+    simpa [hsize, hwidth, byteCount, header] using hreturn
   have hafterSize : Reads
       (do
         let decoded ← Ixon.getU64TrimmedLE byteCount.toNat
+        if decoded < 128 || Ixon.u64ByteCount decoded != (header &&& 0x7f) + 1 then
+          throw "noncanonical Tag0 integer"
         return (⟨decoded⟩ : Ixon.Tag0))
       (trimmedBytes size byteCount.toNat) ⟨size⟩ := by
     simpa [byteCount] using Reads.bind
-      (next := fun decoded : UInt64 =>
-        (pure (⟨decoded⟩ : Ixon.Tag0) : Ixon.GetM Ixon.Tag0))
-      hsizeRead hreturn
+      (next := fun decoded : UInt64 => do
+        if decoded < 128 || Ixon.u64ByteCount decoded != (header &&& 0x7f) + 1 then
+          throw "noncanonical Tag0 integer"
+        return (⟨decoded⟩ : Ixon.Tag0))
+      hsizeRead hcheckedReturn
   have hlargeNe : header &&& 0x80 ≠ 0 := by
     rw [hlarge]
     decide
@@ -664,6 +716,8 @@ theorem getTag0_reads_large (size : UInt64) (hsize : ¬ size < 128) :
           Ixon.getU64TrimmedLE (small.toNat + 1)
         else
           pure small.toUInt64
+        if large && (decodedSize < 128 || Ixon.u64ByteCount decodedSize != small + 1) then
+          throw "noncanonical Tag0 integer"
         return (⟨decodedSize⟩ : Ixon.Tag0))
       (trimmedBytes size byteCount.toNat) ⟨size⟩ := by
     simpa [hlargeNe, hdecodedLen'] using hafterSize
@@ -675,6 +729,8 @@ theorem getTag0_reads_large (size : UInt64) (hsize : ¬ size < 128) :
         Ixon.getU64TrimmedLE (small.toNat + 1)
       else
         pure small.toUInt64
+      if large && (decodedSize < 128 || Ixon.u64ByteCount decodedSize != small + 1) then
+        throw "noncanonical Tag0 integer"
       return (⟨decodedSize⟩ : Ixon.Tag0))
     hheader htail
   simpa [Ixon.getTag0, tag0Bytes, hsize, byteCount, header] using hall
@@ -754,7 +810,8 @@ theorem tag4_large_fields (flag byteCount : UInt8)
     let header := (flag <<< 4) ||| 0x08 ||| (byteCount - 1)
     header >>> 4 = flag ∧
       header &&& 0x08 = 0x08 ∧
-      (header &&& 0x07).toNat + 1 = byteCount.toNat := by
+      (header &&& 0x07).toNat + 1 = byteCount.toNat ∧
+      (header &&& 0x07) + 1 = byteCount := by
   rcases uint8_cases16 flag hflag with
       rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl |
       rfl | rfl | rfl | rfl | rfl | rfl | rfl | rfl <;>
@@ -777,7 +834,7 @@ theorem getTag4_reads_large (flag : UInt8) (size : UInt64)
     simp only [byteCount, hzero, Nat.mul_zero, Nat.pow_zero] at hfit
     omega
   have hcountLe : byteCount.toNat ≤ 8 := u64ByteCount_toNat_le size
-  obtain ⟨hdecodedFlag, hlarge, hdecodedLen⟩ :=
+  obtain ⟨hdecodedFlag, hlarge, hdecodedLen, hwidth⟩ :=
     tag4_large_fields flag byteCount hflag hcountPos hcountLe
   have hdecodedFlag' : header >>> 4 = flag := by
     simpa [header] using hdecodedFlag
@@ -787,15 +844,26 @@ theorem getTag4_reads_large (flag : UInt8) (size : UInt64)
   have hreturn : Reads
       (pure (⟨flag, size⟩ : Ixon.Tag4) : Ixon.GetM Ixon.Tag4)
       ByteArray.empty ⟨flag, size⟩ := Reads.pure _
+  have hcheckedReturn : Reads
+      (do
+        if size < 8 || Ixon.u64ByteCount size != (header &&& 0x07) + 1 then
+          throw "noncanonical Tag4 integer"
+        return (⟨flag, size⟩ : Ixon.Tag4))
+      ByteArray.empty ⟨flag, size⟩ := by
+    simpa [hsize, hwidth, byteCount, header] using hreturn
   have hafterSize : Reads
       (do
         let decoded ← Ixon.getU64TrimmedLE byteCount.toNat
+        if decoded < 8 || Ixon.u64ByteCount decoded != (header &&& 0x07) + 1 then
+          throw "noncanonical Tag4 integer"
         return (⟨flag, decoded⟩ : Ixon.Tag4))
       (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by
     simpa [byteCount] using Reads.bind
-      (next := fun decoded : UInt64 =>
-        (pure (⟨flag, decoded⟩ : Ixon.Tag4) : Ixon.GetM Ixon.Tag4))
-      hsizeRead hreturn
+      (next := fun decoded : UInt64 => do
+        if decoded < 8 || Ixon.u64ByteCount decoded != (header &&& 0x07) + 1 then
+          throw "noncanonical Tag4 integer"
+        return (⟨flag, decoded⟩ : Ixon.Tag4))
+      hsizeRead hcheckedReturn
   have hlargeNe : header &&& 0x08 ≠ 0 := by
     rw [hlarge]
     decide
@@ -810,6 +878,8 @@ theorem getTag4_reads_large (flag : UInt8) (size : UInt64)
           Ixon.getU64TrimmedLE (small.toNat + 1)
         else
           pure small.toUInt64
+        if large && (decodedSize < 8 || Ixon.u64ByteCount decodedSize != small + 1) then
+          throw "noncanonical Tag4 integer"
         return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag4))
       (trimmedBytes size byteCount.toNat) ⟨flag, size⟩ := by
     simpa [hdecodedFlag', hlargeNe, hdecodedLen'] using hafterSize
@@ -822,6 +892,8 @@ theorem getTag4_reads_large (flag : UInt8) (size : UInt64)
         Ixon.getU64TrimmedLE (small.toNat + 1)
       else
         pure small.toUInt64
+      if large && (decodedSize < 8 || Ixon.u64ByteCount decodedSize != small + 1) then
+        throw "noncanonical Tag4 integer"
       return (⟨decodedFlag, decodedSize⟩ : Ixon.Tag4))
     hheader htail
   simpa [Ixon.getTag4, tag4Bytes, hsize, byteCount, header] using hall
diff --git a/Ix/Compile/Verify/CompileExpr.lean b/Ix/Compile/Verify/CompileExpr.lean
index 8d2cf06a9..a7494f8cb 100644
--- a/Ix/Compile/Verify/CompileExpr.lean
+++ b/Ix/Compile/Verify/CompileExpr.lean
@@ -112,7 +112,7 @@ inductive StructuralExpr : Ix.Expr → Prop where
       StructuralExpr (.mdata #[] inner hash)
 
 /-- The complete ordinary syntax accepted by the no-surgery compiler,
-including arbitrary totalized metadata maps. -/
+including totalized presentation metadata outside the semantic-contract namespace. -/
 inductive OrdinaryExpr : Ix.Expr → Prop where
   | bvar {idx hash} : OrdinaryExpr (.bvar idx hash)
   | sort {level hash} : OrdinaryExpr (.sort level hash)
@@ -129,7 +129,7 @@ inductive OrdinaryExpr : Ix.Expr → Prop where
   | lit {literal hash} : OrdinaryExpr (.lit literal hash)
   | proj {typeName field val hash} : OrdinaryExpr val →
       OrdinaryExpr (.proj typeName field val hash)
-  | mdata {data inner hash} : OrdinaryExpr inner →
+  | mdata {data inner hash} : SemanticContract.hasMetadata data = false → OrdinaryExpr inner →
       OrdinaryExpr (.mdata data inner hash)
 
 theorem StructuralExpr.ordinary {source : Ix.Expr} :
@@ -140,7 +140,7 @@ theorem StructuralExpr.ordinary {source : Ix.Expr} :
   | .all hty hbody => .all hty.ordinary hbody.ordinary
   | .letE hty hval hbody =>
     .letE hty.ordinary hval.ordinary hbody.ordinary
-  | .mdata hinner => .mdata hinner.ordinary
+  | .mdata hinner => .mdata (by simp [SemanticContract.hasMetadata]) hinner.ordinary
 
 /-- Ordinary syntax paired with the exact finite universe support needed by
 production `compileUniv`.  This is the recursive source domain of the frozen
@@ -171,7 +171,8 @@ inductive SupportedOrdinaryExpr (levelSupport : Ix.Level → Prop) :
       SupportedOrdinaryExpr levelSupport (.lit literal hash)
   | proj {typeName field val hash} : SupportedOrdinaryExpr levelSupport val →
       SupportedOrdinaryExpr levelSupport (.proj typeName field val hash)
-  | mdata {data inner hash} : SupportedOrdinaryExpr levelSupport inner →
+  | mdata {data inner hash} : SemanticContract.hasMetadata data = false →
+      SupportedOrdinaryExpr levelSupport inner →
       SupportedOrdinaryExpr levelSupport (.mdata data inner hash)
 
 theorem SupportedOrdinaryExpr.ordinary {levelSupport : Ix.Level → Prop}
@@ -187,7 +188,7 @@ theorem SupportedOrdinaryExpr.ordinary {levelSupport : Ix.Level → Prop}
     .letE hty.ordinary hval.ordinary hbody.ordinary
   | .lit => .lit
   | .proj hval => .proj hval.ordinary
-  | .mdata hinner => .mdata hinner.ordinary
+  | .mdata hplain hinner => .mdata hplain hinner.ordinary
 
 /-- Every production expression-cache entry in this slice came from the same
 reference compiler and belongs to the supported structural fragment. -/
@@ -1002,8 +1003,9 @@ private theorem compileExprNoSurgeryStep_structural_refines
     let root := innerState.arena.nodes.size.toUInt64
     let state' := allocState innerState (.mdata #[#[]] innerRoot)
     refine ⟨root, state', ?_, hinnerState.of_cache_eq (by rfl)⟩
-    rw [Ix.CompileM.compileExprNoSurgeryStep,
-      run_bind compileEnv blockEnv state _ _, run_compileEmptyKVMap]
+    simp only [Ix.CompileM.compileExprNoSurgeryStep,
+      show SemanticContract.hasMetadata #[] = false from by simp [SemanticContract.hasMetadata], Bool.false_eq_true, ↓reduceIte]
+    rw [run_bind compileEnv blockEnv state _ _, run_compileEmptyKVMap]
     simp only
     rw [run_bind compileEnv blockEnv state _ _, hinnerRun]
     simp only
@@ -2544,9 +2546,9 @@ private theorem compileAppNoSurgery_ordinary_refines
   | proj hval ihval =>
     simpa [Ix.CompileM.compileAppNoSurgery] using
       hrecur hdepth (SupportedOrdinaryExpr.proj hval) hstate href
-  | mdata hinner ihinner =>
+  | mdata hplain hinner ihinner =>
     simpa [Ix.CompileM.compileAppNoSurgery] using
-      hrecur hdepth (SupportedOrdinaryExpr.mdata hinner) hstate href
+      hrecur hdepth (SupportedOrdinaryExpr.mdata hplain hinner) hstate href
   | @app fn arg hash hfn harg ihfn iharg =>
     simp [compileExprRef] at href
     rcases href with ⟨fnTarget, hfnRef, argTarget, hargRef, rfl⟩
@@ -2637,9 +2639,9 @@ private theorem compileAppNoSurgery_ordinary_arena_refines
   | proj hval ihval =>
     simpa [Ix.CompileM.compileAppNoSurgery] using
       hrecur hdepth (SupportedOrdinaryExpr.proj hval) hstate harena hroom href
-  | mdata hinner ihinner =>
+  | mdata hplain hinner ihinner =>
     simpa [Ix.CompileM.compileAppNoSurgery] using
-      hrecur hdepth (SupportedOrdinaryExpr.mdata hinner) hstate harena hroom
+      hrecur hdepth (SupportedOrdinaryExpr.mdata hplain hinner) hstate harena hroom
         href
   | @app fn arg hash hfn harg ihfn iharg =>
     simp [compileExprRef] at href
@@ -3039,7 +3041,7 @@ private theorem compileExprNoSurgeryStep_ordinary_refines
         simp only
         rw [run_bind compileEnv blockEnv valState _ _, run_allocArenaNode]
         rfl
-  | @mdata data inner hash hinner =>
+  | @mdata data inner hash hplain hinner =>
     have hinnerRef :
         compileExprRef (frozenRefCompileCtx compileEnv blockEnv snapshot)
             inner = some target := by
@@ -3060,8 +3062,8 @@ private theorem compileExprNoSurgeryStep_ordinary_refines
     let finalState := allocState innerState node
     refine ⟨root, finalState, ?_,
       hinnerState.alloc node⟩
-    rw [Ix.CompileM.compileExprNoSurgeryStep,
-      run_bind compileEnv blockEnv state _ _, hmetaRun]
+    simp only [Ix.CompileM.compileExprNoSurgeryStep, hplain, Bool.false_eq_true, ↓reduceIte]
+    rw [run_bind compileEnv blockEnv state _ _, hmetaRun]
     simp only
     rw [run_bind compileEnv blockEnv metaState _ _, hinnerRun]
     simp only
@@ -3933,7 +3935,7 @@ private theorem compileExprNoSurgeryStep_ordinary_arena_refines
         simp only
         rw [run_bind compileEnv blockEnv valState _ _, run_allocArenaNode]
         rfl
-  | @mdata data inner hash hinner =>
+  | @mdata data inner hash hplain hinner =>
     have hinnerRef :
         compileExprRef (frozenRefCompileCtx compileEnv blockEnv snapshot)
             inner = some target := by
@@ -3989,8 +3991,8 @@ private theorem compileExprNoSurgeryStep_ordinary_arena_refines
           rw [← hmetaFrame.arena]
           exact ArenaExtends.trans hinnerArena.arenaExtends hallocExtends),
         hfinalGrowth⟩⟩
-    rw [Ix.CompileM.compileExprNoSurgeryStep,
-      run_bind compileEnv blockEnv state _ _, hmetaRun]
+    simp only [Ix.CompileM.compileExprNoSurgeryStep, hplain, Bool.false_eq_true, ↓reduceIte]
+    rw [run_bind compileEnv blockEnv state _ _, hmetaRun]
     simp only
     rw [run_bind compileEnv blockEnv metaState _ _, hinnerRun]
     simp only
@@ -4371,3 +4373,5 @@ theorem compileExpr_run_surgeryFree
   simp [hfree]
 
 end Ix.Compile.Verify
+
+
diff --git a/Ix/Compile/Verify/CompileMutualCodec.lean b/Ix/Compile/Verify/CompileMutualCodec.lean
index 4dd8c9d60..d5e192bf1 100644
--- a/Ix/Compile/Verify/CompileMutualCodec.lean
+++ b/Ix/Compile/Verify/CompileMutualCodec.lean
@@ -1755,6 +1755,7 @@ inductive CompareExprReady
       CompareExprReady compileEnv ctx levelCtx origin
         (.proj typeName field value hash)
   | mdata {data inner hash} :
+      SemanticContract.hasMetadata data = false →
       CompareExprReady compileEnv ctx levelCtx origin inner →
       CompareExprReady compileEnv ctx levelCtx origin
         (.mdata data inner hash)
@@ -1794,7 +1795,7 @@ theorem PreseedReady.compareReady
         obtain ⟨addr, haddr, _⟩ := hresolve
         exact ⟨addr, haddr⟩
       · exact ihvalue
-  | mdata _ ihinner => exact .mdata ihinner
+  | mdata hplain _ ihinner => exact .mdata hplain ihinner
 
 /-- Comparison readiness is insensitive to state fields outside the frozen
 expression-table view (in particular, to comparison-cache inserts). -/
@@ -1828,7 +1829,7 @@ theorem CompareExprReady.of_exprTableView_eq
         rw [resolveConstAddr?_of_exprTableView_eq compileEnv hview]
         exact haddr
       · exact ihvalue
-  | mdata _ ihinner => exact .mdata ihinner
+  | mdata hplain _ ihinner => exact .mdata hplain ihinner
 
 private theorem compareLevelList_run_ready
     (compileEnv : Ix.CompileM.CompileEnv)
@@ -1883,14 +1884,16 @@ theorem compareExpr_run_ready
   cases hx with
   | bvar =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ .bvar hyinner
       | bvar | sort | const | app | lam | all | letE | lit | proj =>
           exact ⟨_, rfl⟩
   | sort hxlevel =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.sort hxlevel) hyinner
       | sort hylevel =>
@@ -1900,7 +1903,8 @@ theorem compareExpr_run_ready
           exact ⟨_, rfl⟩
   | @const xname xlevels xhash hxlevels hxresolve =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.const hxlevels hxresolve) hyinner
       | @const yname ylevels yhash hylevels hyresolve =>
@@ -1936,7 +1940,8 @@ theorem compareExpr_run_ready
           exact ⟨_, rfl⟩
   | app hxfn hxarg =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.app hxfn hxarg) hyinner
       | app hyfn hyarg =>
@@ -1950,7 +1955,8 @@ theorem compareExpr_run_ready
           exact ⟨_, rfl⟩
   | lam hxty hxbody =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.lam hxty hxbody) hyinner
       | lam hyty hybody =>
@@ -1964,7 +1970,8 @@ theorem compareExpr_run_ready
           exact ⟨_, rfl⟩
   | all hxty hxbody =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.all hxty hxbody) hyinner
       | all hyty hybody =>
@@ -1978,7 +1985,8 @@ theorem compareExpr_run_ready
           exact ⟨_, rfl⟩
   | letE hxty hxvalue hxbody =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.letE hxty hxvalue hxbody) hyinner
       | letE hyty hyvalue hybody =>
@@ -1997,14 +2005,16 @@ theorem compareExpr_run_ready
           exact ⟨_, rfl⟩
   | lit =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ .lit hyinner
       | bvar | sort | const | app | lam | all | letE | lit | proj =>
           exact ⟨_, rfl⟩
   | @proj xtypeName xfield xvalue xhash hxresolve hxvalue =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hyplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ (.proj hxresolve hxvalue) hyinner
       | @proj ytypeName yfield yvalue yhash hyresolve hyvalue =>
@@ -2050,36 +2060,46 @@ theorem compareExpr_run_ready
                     exact htail ⟨true, compare xaddr yaddr⟩
       | bvar | sort | const | app | lam | all | letE | lit =>
           exact ⟨_, rfl⟩
-  | mdata hxinner =>
+  | mdata hxplain hxinner =>
       cases hy with
-      | mdata hyinner =>
+      | mdata hyplain hyinner =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
-            xlvls ylvls _ _ hxinner hyinner
+            xlvls ylvls _ _ hxinner (.mdata hyplain hyinner)
       | bvar =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner .bvar
       | sort hylevel =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.sort hylevel)
       | const hylevels hyresolve =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.const hylevels hyresolve)
       | app hyfn hyarg =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.app hyfn hyarg)
       | lam hyty hybody =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.lam hyty hybody)
       | all hyty hybody =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.all hyty hybody)
       | letE hyty hyvalue hybody =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.letE hyty hyvalue hybody)
       | lit =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner .lit
       | proj hyresolve hyvalue =>
+          simp only [hxplain, Bool.false_eq_true, ite_false]
           exact compareExpr_run_ready compileEnv blockEnv state ctx
             xlvls ylvls _ _ hxinner (.proj hyresolve hyvalue)
 termination_by Ix.CompileM.compareExprSize x +
diff --git a/Ix/Compile/Verify/CompilePreseed.lean b/Ix/Compile/Verify/CompilePreseed.lean
index 2611fa215..33a804f9f 100644
--- a/Ix/Compile/Verify/CompilePreseed.lean
+++ b/Ix/Compile/Verify/CompilePreseed.lean
@@ -275,6 +275,7 @@ inductive PreseedReady
       PreseedReady compileEnv blockEnv levelSupport origin
         (.proj typeName field val hash)
   | mdata {data inner hash} :
+      SemanticContract.hasMetadata data = false →
       PreseedReady compileEnv blockEnv levelSupport origin inner →
       PreseedReady compileEnv blockEnv levelSupport origin
         (.mdata data inner hash)
@@ -295,7 +296,7 @@ theorem PreseedReady.supported
     .letE hty.supported hval.supported hbody.supported
   | .lit => .lit
   | .proj _ hval => .proj hval.supported
-  | .mdata hinner => .mdata hinner.supported
+  | .mdata hplain hinner => .mdata hplain hinner.supported
 
 /-- Every payload accumulated so far is suitable for its eventual primary
 table: addresses have the fixed BLAKE3 width and raw universes canonicalize
@@ -822,7 +823,7 @@ theorem PreseedCollectionCovers.compileExprRef_of_indexed
     obtain ⟨tyTarget, htyTarget⟩ := ihty
     obtain ⟨valueTarget, hvalueTarget⟩ := ihvalue
     obtain ⟨bodyTarget, hbodyTarget⟩ := ihbody
-    exact ⟨.letE nonDep tyTarget valueTarget bodyTarget,
+    exact ⟨.leanLet nonDep tyTarget valueTarget bodyTarget,
       by simp [compileExprRef, htyTarget, hvalueTarget, hbodyTarget]⟩
   | @lit literal hash hmem =>
     obtain ⟨idx, hidx⟩ := hindexed.refs (literalAddress literal) hmem
@@ -1333,7 +1334,7 @@ theorem collectExprTablesStructural_run_ready
       · have hvalUniv := hvalSize.univs
         dsimp [preseedUnivCount] at hvalUniv ⊢
         omega
-  | @mdata data inner hash hinner ihinner =>
+  | @mdata data inner hash hplain hinner ihinner =>
     rcases acc with ⟨refs, univs, seen⟩
     rw [Ix.CompileM.collectExprTablesStructural]
     by_cases hseen : seen.contains
@@ -1812,10 +1813,10 @@ theorem collectExprTablesStructural_run_ready_covers
         hvalueSeen.dropHead hexprFaithful hordinary hcovered⟩
       rw [run_bind, hlookup]
       exact hvalueRun
-  | @mdata data inner hash hinner ihinner =>
+  | @mdata data inner hash hplain hinner ihinner =>
     rcases acc with ⟨refs, univs, seen⟩
     let source := Ix.Expr.mdata data inner hash
-    have hordinary : OrdinaryExpr source := .mdata hinner.supported.ordinary
+    have hordinary : OrdinaryExpr source := .mdata hplain hinner.supported.ordinary
     rw [Ix.CompileM.collectExprTablesStructural]
     by_cases hhit : seen.contains (source.getHash, ctxKey) = true
     · rw [if_pos hhit]
@@ -4825,3 +4826,4 @@ theorem preseedExprTables_run_univsFinal
           rfl
 
 end Ix.Compile.Verify
+
diff --git a/Ix/Compile/Verify/ConstantCodec.lean b/Ix/Compile/Verify/ConstantCodec.lean
index 49ba11b8c..b754f21ac 100644
--- a/Ix/Compile/Verify/ConstantCodec.lean
+++ b/Ix/Compile/Verify/ConstantCodec.lean
@@ -1,7 +1,7 @@
 import Ix.Compile.Verify.ExprSpineCodec
 
 /-!
-# Proof-visible v2 core constant codec
+# Proof-visible v3 core constant codec
 
 This slice composes the verified arbitrary-spine expression codec through
 production definition and axiom payloads, their `ConstantInfo` tags, and a
@@ -30,6 +30,19 @@ theorem unpackDefKindSafety_pack (kind : DefKind)
       (kind, safety) := by
   cases kind <;> cases safety <;> decide
 
+theorem packDefKindSafety_valid (kind : DefKind) (safety : DefinitionSafety) :
+    ((Ixon.packDefKindSafety kind safety >>> 2 > 2) ||
+      (Ixon.packDefKindSafety kind safety &&& 3 > 2)) = false := by
+  cases kind <;> cases safety <;> decide
+
+theorem getBool_reads (value : Bool) :
+    Reads (Ixon.Serialize.get (α := Bool))
+      [if value then 1 else 0].toByteArray value := by
+  cases value <;> intro before after <;>
+    change (EStateM.bind Ixon.getU8 _) _ = _
+  all_goals rw [EStateM.bind, getU8_reads _ before after]
+  all_goals rfl
+
 theorem putDefinition_writes (definition : Ixon.Definition)
     (htyp : Ixon.Expr.wireWF definition.typ)
     (hvalue : Ixon.Expr.wireWF definition.value) :
@@ -91,21 +104,37 @@ theorem getDefinition_reads (definition : Ixon.Definition)
       definition := by
     rw [unpackDefKindSafety_pack]
     simpa [ByteArray.append_assoc] using hafterLvls
+  have hchecked : Reads
+      (do
+        let packed := Ixon.packDefKindSafety definition.kind definition.safety
+        if packed >>> 2 > 2 || (packed &&& 3) > 2 then
+          throw "invalid definition kind/safety"
+        let (kind, safety) := Ixon.unpackDefKindSafety packed
+        let lvls := (← Ixon.getTag0).size
+        let typ ← Ixon.getExpr
+        let value ← Ixon.getExpr
+        return (⟨kind, safety, lvls, typ, value⟩ : Ixon.Definition))
+      (tag0Bytes definition.lvls ++ Expr.spineWireEncode definition.typ ++
+        Expr.spineWireEncode definition.value) definition := by
+    simpa only [packDefKindSafety_valid, Bool.false_eq_true, if_false]
+      using hafterLvls'
   have hall := Reads.bind
     (next := fun packed : UInt8 => do
+      if packed >>> 2 > 2 || (packed &&& 3) > 2 then
+        throw "invalid definition kind/safety"
       let (kind, safety) := Ixon.unpackDefKindSafety packed
       let lvls := (← Ixon.getTag0).size
       let typ ← Ixon.getExpr
       let value ← Ixon.getExpr
       return (⟨kind, safety, lvls, typ, value⟩ : Ixon.Definition))
-    hkind hafterLvls'
+    hkind hchecked
   simpa [Ixon.getDefinition, definitionBytes, unpackDefKindSafety_pack,
     ByteArray.append_assoc] using hall
 
 theorem getAxiom_reads (axiomInfo : Ixon.Axiom)
     (htyp : Ixon.Expr.wireWF axiomInfo.typ) :
     Reads Ixon.getAxiom (axiomBytes axiomInfo) axiomInfo := by
-  have hbool := getU8_reads (if axiomInfo.isUnsafe then 1 else 0)
+  have hbool := getBool_reads axiomInfo.isUnsafe
   have hlvls := getTag0_reads axiomInfo.lvls
   have htypRead := Expr.getExpr_reads_spine axiomInfo.typ htyp
   have hreturn := Reads.pure axiomInfo
@@ -118,27 +147,12 @@ theorem getAxiom_reads (axiomInfo : Ixon.Axiom)
       let typ ← Ixon.getExpr
       return ({ axiomInfo with lvls := lvls.size, typ } : Ixon.Axiom))
     hlvls hafterTyp
-  have hdecodeUnsafe :
-      (((if axiomInfo.isUnsafe then 1 else 0) : UInt8) != 0) =
-        axiomInfo.isUnsafe := by
-    cases axiomInfo.isUnsafe <;> decide
-  have hafterLvls' : Reads
-      (do
-        let lvls := (← Ixon.getTag0).size
-        let typ ← Ixon.getExpr
-        return (⟨(((if axiomInfo.isUnsafe then 1 else 0) : UInt8) != 0),
-          lvls, typ⟩ : Ixon.Axiom))
-      (tag0Bytes axiomInfo.lvls ++ Expr.spineWireEncode axiomInfo.typ)
-      axiomInfo := by
-    simp only [hdecodeUnsafe]
-    simpa using hafterLvls
   have hall := Reads.bind
-    (next := fun encodedUnsafe : UInt8 => do
-      let isUnsafe := encodedUnsafe != 0
+    (next := fun isUnsafe : Bool => do
       let lvls := (← Ixon.getTag0).size
       let typ ← Ixon.getExpr
       return (⟨isUnsafe, lvls, typ⟩ : Ixon.Axiom))
-    hbool hafterLvls'
+    hbool hafterLvls
   simpa [Ixon.getAxiom, axiomBytes, ByteArray.append_assoc] using hall
 
 theorem runGet_runPut_definition (definition : Ixon.Definition)
diff --git a/Ix/Compile/Verify/ExprCodec.lean b/Ix/Compile/Verify/ExprCodec.lean
index de91cf8cf..2c3e69849 100644
--- a/Ix/Compile/Verify/ExprCodec.lean
+++ b/Ix/Compile/Verify/ExprCodec.lean
@@ -1,7 +1,7 @@
 import Ix.Compile.Verify.Codec
 
 /-!
-# Proof-visible v2 expression codec
+# Proof-visible v3 expression codec
 
 This expression slice proves the production writer/reader inverse for all
 constructors with wire-sized universe-instantiation vectors and canonical
@@ -82,17 +82,27 @@ def wireEncode : Ixon.Expr → ByteArray
         ([uses.toBits].toByteArray ++ (wireEncode ty ++ wireEncode body))
   | .all uses owned ty body =>
       tag4Bytes Ixon.Expr.FLAG_ALL 1 ++
-        ([uses.toBits ||| (owned.toBits <<< 2)].toByteArray ++
+        ([Ixon.packAllContract uses owned].toByteArray ++
           (wireEncode ty ++ wireEncode body))
   | .letE nonDep ty val body =>
-      tag4Bytes Ixon.Expr.FLAG_LET (if nonDep then 1 else 0) ++
-        wireEncode ty ++ wireEncode val ++ wireEncode body
+      tag4Bytes Ixon.Expr.FLAG_LET nonDep.flags ++
+        ([nonDep.binder.toBits].toByteArray ++
+          (wireEncode ty ++ (wireEncode val ++ wireEncode body)))
   | .share idx => tag4Bytes Ixon.Expr.FLAG_SHARE idx
 
 theorem tag0Bytes_size_pos (size : UInt64) : 0 < (tag0Bytes size).size := by
   unfold tag0Bytes
   split <;> simp <;> omega
 
+theorem tag0ListBytes_size_ge_length (idxs : List UInt64) :
+    idxs.length ≤ (tag0ListBytes idxs).size := by
+  induction idxs with
+  | nil => simp [tag0ListBytes]
+  | cons idx idxs ih =>
+    have hpos := tag0Bytes_size_pos idx
+    simp only [tag0ListBytes, ByteArray.size_append, List.length_cons]
+    omega
+
 theorem tag4Bytes_size_pos (flag : UInt8) (size : UInt64) :
     0 < (tag4Bytes flag size).size := by
   unfold tag4Bytes
@@ -130,17 +140,28 @@ theorem wireEncode_size_pos (e : Ixon.Expr) : 0 < (wireEncode e).size := by
     omega
   | letE nonDep ty val body =>
     have h := tag4Bytes_size_pos Ixon.Expr.FLAG_LET
-      (if nonDep then 1 else 0)
+      nonDep.flags
     simp only [wireEncode, ByteArray.size_append]
     omega
   | share idx =>
     simpa [wireEncode] using tag4Bytes_size_pos Ixon.Expr.FLAG_SHARE idx
 
-theorem forallMode_fields (uses : Ixon.Uses) (owned : Ixon.Owned) :
-    let mode := uses.toBits ||| (owned.toBits <<< 2)
-    mode ≤ 7 ∧ Ixon.Uses.ofBits? (mode &&& 0x03) = some uses ∧
-      Ixon.Owned.ofBits? ((mode >>> 2) &&& 0x01) = some owned := by
-  cases uses <;> cases owned <;> decide
+theorem forallMode_fields (uses : Ixon.BinderContract) (owned : Ixon.ValueContract) :
+    Ixon.unpackAllContract? (Ixon.packAllContract uses owned) = some (uses, owned) :=
+  Ixon.unpackAllContract?_packAllContract uses owned
+
+theorem getBinderContract_reads (binder : Ixon.BinderContract) :
+    Reads Ixon.getBinderContract [binder.toBits].toByteArray binder := by
+  intro before after
+  unfold Ixon.getBinderContract
+  change (EStateM.bind Ixon.getU8 _) _ = _
+  rw [EStateM.bind, getU8_reads binder.toBits before after]
+  simp only [Ixon.BinderContract.ofBits?_toBits]
+  rfl
+
+theorem letFlags_not_gt (contract : Ixon.LetContract) : ¬ contract.flags > 3 := by
+  rcases contract with ⟨nonDep, kind, binder⟩
+  cases nonDep <;> cases kind <;> simp [Ixon.LetContract.flags] <;> decide
 
 theorem indexVectorWF_count (idxs : Array UInt64) (h : IndexVectorWF idxs) :
     idxs.size.toUInt64.toNat = idxs.size := by
@@ -254,16 +275,18 @@ theorem putExpr_writes_single (e : Ixon.Expr) (h : SingleWireWF e) :
         ([(uses, owned, ty)], body) := by
       simp [Ixon.Expr.collectAllBinders, hcollect]
     have hwrite := (putTag4_writes Ixon.Expr.FLAG_ALL 1).bind
-      ((putU8_writes (uses.toBits ||| (owned.toBits <<< 2))).bind
+      ((putU8_writes (Ixon.packAllContract uses owned)).bind
         ((ihTy hty).bind (ihBody hbody)))
     simpa [Ixon.putExpr, wireEncode, hspine, byteArray_append_singleton,
       ByteArray.append_assoc] using hwrite
   | letE nonDep ty val body ihTy ihVal ihBody =>
     obtain ⟨hty, hval, hbody⟩ := h
     have hwrite :=
-      (putTag4_writes Ixon.Expr.FLAG_LET (if nonDep then 1 else 0)).bind
-        ((ihTy hty).bind ((ihVal hval).bind (ihBody hbody)))
-    simpa [Ixon.putExpr, wireEncode, ByteArray.append_assoc] using hwrite
+      (putTag4_writes Ixon.Expr.FLAG_LET nonDep.flags).bind
+        ((putU8_writes nonDep.binder.toBits).bind
+          ((ihTy hty).bind ((ihVal hval).bind (ihBody hbody))))
+    simpa [Ixon.putExpr, Ixon.putBinderContract, wireEncode,
+      ByteArray.append_assoc] using hwrite
   | share idx =>
     simpa [Ixon.putExpr, wireEncode] using
       putTag4_writes Ixon.Expr.FLAG_SHARE idx
@@ -327,12 +350,16 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
           (pure (Ixon.Expr.ref refIdx decoded.toArray) :
             Ixon.GetM Ixon.Expr))
         hunivs hreturn
+      have hcheckedUnivs := Reads.checkCount univs.size.toUInt64 1
+        (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList)
+        hafterUnivs
       have htail := Reads.bind
         (next := fun decoded : Ixon.Tag0 =>
           (do
+            Ixon.checkCount univs.size.toUInt64
             let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length
             return Ixon.Expr.ref decoded.size decodedUnivs.toArray))
-        hidx hafterUnivs
+        hidx hcheckedUnivs
       have hparsed : Reads
           (Ixon.getExprFromTag (Ixon.getExprFuel fuel)
             ⟨Ixon.Expr.FLAG_REF, univs.size.toUInt64⟩)
@@ -363,12 +390,16 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
           (pure (Ixon.Expr.recur recIdx decoded.toArray) :
             Ixon.GetM Ixon.Expr))
         hunivs hreturn
+      have hcheckedUnivs := Reads.checkCount univs.size.toUInt64 1
+        (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList)
+        hafterUnivs
       have htail := Reads.bind
         (next := fun decoded : Ixon.Tag0 =>
           (do
+            Ixon.checkCount univs.size.toUInt64
             let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length
             return Ixon.Expr.recur decoded.size decodedUnivs.toArray))
-        hidx hafterUnivs
+        hidx hcheckedUnivs
       have hparsed : Reads
           (Ixon.getExprFromTag (Ixon.getExprFuel fuel)
             ⟨Ixon.Expr.FLAG_REC, univs.size.toUInt64⟩)
@@ -469,12 +500,18 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
           (wireEncode fn ++ wireEncode arg) (.app fn arg) := by
         change Reads
           (do
+            Ixon.checkCount 1 1
             let base ← Ixon.getExprFuel fuel
             match base with
             | .app .. => throw "getExpr: non-canonical app base"
             | _ => pure ()
             Ixon.getExprAppArgs (Ixon.getExprFuel fuel) 1 base)
           (wireEncode fn ++ wireEncode arg) (.app fn arg)
+        apply Reads.checkCount 1 1
+          (by
+            have hpos := wireEncode_size_pos fn
+            simp only [ByteArray.size_append, UInt64.reduceToNat, Nat.one_mul]
+            omega)
         apply Reads.bind hfnRead
         cases fn <;> simp_all [notApp, Ixon.getExprAppArgs] <;>
           simpa [Ixon.getExprAppArgs] using hafterArg
@@ -497,18 +534,18 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
       have htyRead := ihTy hty fuel (by omega)
       have hbodyRead := ihBody hbody fuel (by omega)
       have htag := getTag4_reads Ixon.Expr.FLAG_LAM 1 (by decide)
-      have hmode := getU8_reads uses.toBits
+      have hmode := getBinderContract_reads uses
       have hempty : Reads
           (Ixon.getExprLamBinders (Ixon.getExprFuel fuel) 0)
           ByteArray.empty [] := by
         simpa [Ixon.getExprLamBinders] using
-          (Reads.pure ([] : List (Ixon.Uses × Ixon.Expr)))
+          (Reads.pure ([] : List (Ixon.BinderContract × Ixon.Expr)))
       have hlistReturn :=
-        Reads.pure ([(uses, ty)] : List (Ixon.Uses × Ixon.Expr))
+        Reads.pure ([(uses, ty)] : List (Ixon.BinderContract × Ixon.Expr))
       have hafterEmpty := Reads.bind
-        (next := fun tail : List (Ixon.Uses × Ixon.Expr) =>
+        (next := fun tail : List (Ixon.BinderContract × Ixon.Expr) =>
           (pure ((uses, ty) :: tail) :
-            Ixon.GetM (List (Ixon.Uses × Ixon.Expr))))
+            Ixon.GetM (List (Ixon.BinderContract × Ixon.Expr))))
         hempty hlistReturn
       have hafterTy := Reads.bind
         (next := fun decodedTy : Ixon.Expr => do
@@ -545,6 +582,7 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
           (.lam uses ty body) := by
         change Reads
           (do
+            Ixon.checkCount 1 2
             let binders ← Ixon.getExprLamBinders
               (Ixon.getExprFuel fuel) 1
             let decodedBody ← Ixon.getExprFuel fuel
@@ -555,6 +593,13 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
               (fun (u, t) result => Ixon.Expr.lam u t result) decodedBody)
           ([uses.toBits].toByteArray ++ wireEncode ty ++ wireEncode body)
           (.lam uses ty body)
+        apply Reads.checkCount 1 2
+          (by
+            have hpos := wireEncode_size_pos ty
+            simp only [ByteArray.size_append, List.size_toByteArray,
+              List.length_cons, List.length_nil, UInt64.reduceToNat,
+              Nat.one_mul]
+            omega)
         apply Reads.bind hbinders
         simpa using hbodyParsed
       have hall := Reads.bind
@@ -566,7 +611,7 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
     cases fuel with
     | zero => have hpos := wireEncode_size_pos (.all uses owned ty body); omega
     | succ fuel =>
-      let mode := uses.toBits ||| (owned.toBits <<< 2)
+      let mode := Ixon.packAllContract uses owned
       have hsizes :
           (tag4Bytes Ixon.Expr.FLAG_ALL 1).size + 1 +
               (wireEncode ty).size + (wireEncode body).size ≤ fuel + 1 := by
@@ -579,25 +624,17 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
       have htag := getTag4_reads Ixon.Expr.FLAG_ALL 1 (by decide)
       have hmode := getU8_reads mode
       have hfields := forallMode_fields uses owned
-      obtain ⟨hmodeLe, huses, howned⟩ := hfields
-      change mode ≤ 7 at hmodeLe
-      change Ixon.Uses.ofBits? (mode &&& 0x03) = some uses at huses
-      change Ixon.Owned.ofBits? ((mode >>> 2) &&& 0x01) = some owned at howned
-      have hmodeNotGt : ¬ mode > 7 := by
-        simp only [UInt8.le_iff_toNat_le] at hmodeLe
-        simp only [UInt8.lt_iff_toNat_lt]
-        omega
       have hempty : Reads
           (Ixon.getExprAllBinders (Ixon.getExprFuel fuel) 0)
           ByteArray.empty [] := by
         simpa [Ixon.getExprAllBinders] using
-          (Reads.pure ([] : List (Ixon.Uses × Ixon.Owned × Ixon.Expr)))
+          (Reads.pure ([] : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)))
       have hlistReturn := Reads.pure
-        ([(uses, owned, ty)] : List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+        ([(uses, owned, ty)] : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
       have hafterEmpty := Reads.bind
-        (next := fun tail : List (Ixon.Uses × Ixon.Owned × Ixon.Expr) =>
+        (next := fun tail : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr) =>
           (pure ((uses, owned, ty) :: tail) :
-            Ixon.GetM (List (Ixon.Uses × Ixon.Owned × Ixon.Expr))))
+            Ixon.GetM (List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))))
         hempty hlistReturn
       have hafterTy := Reads.bind
         (next := fun decodedTy : Ixon.Expr => do
@@ -609,8 +646,7 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
           ([mode].toByteArray ++ wireEncode ty) [(uses, owned, ty)] := by
         rw [Ixon.getExprAllBinders]
         apply Reads.bind hmode
-        simp only [if_neg hmodeNotGt, huses, howned]
-        simpa using hafterTy
+        simpa only [mode, hfields, ByteArray.append_empty] using hafterTy
       have hfinish : Reads
           (do
             match body with
@@ -635,6 +671,7 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
           (.all uses owned ty body) := by
         change Reads
           (do
+            Ixon.checkCount 1 2
             let binders ← Ixon.getExprAllBinders
               (Ixon.getExprFuel fuel) 1
             let decodedBody ← Ixon.getExprFuel fuel
@@ -646,6 +683,13 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
               decodedBody)
           ([mode].toByteArray ++ wireEncode ty ++ wireEncode body)
           (.all uses owned ty body)
+        apply Reads.checkCount 1 2
+          (by
+            have hpos := wireEncode_size_pos ty
+            simp only [ByteArray.size_append, List.size_toByteArray,
+              List.length_cons, List.length_nil, UInt64.reduceToNat,
+              Nat.one_mul]
+            omega)
         apply Reads.bind hbinders
         simpa using hbodyParsed
       have hall := Reads.bind
@@ -659,17 +703,19 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
     | zero => have hpos := wireEncode_size_pos (.letE nonDep ty val body); omega
     | succ fuel =>
       have hsizes :
-          (tag4Bytes Ixon.Expr.FLAG_LET (if nonDep then 1 else 0)).size +
+          (tag4Bytes Ixon.Expr.FLAG_LET nonDep.flags).size + 1 +
               (wireEncode ty).size + (wireEncode val).size +
                 (wireEncode body).size ≤ fuel + 1 := by
-        simpa only [wireEncode, ByteArray.size_append] using hfuel
+        simpa only [wireEncode, ByteArray.size_append,
+          List.size_toByteArray, List.length_cons, List.length_nil,
+          Nat.zero_add, Nat.add_assoc] using hfuel
       have htagPos := tag4Bytes_size_pos Ixon.Expr.FLAG_LET
-        (if nonDep then 1 else 0)
+        nonDep.flags
       have htyRead := ihTy hty fuel (by omega)
       have hvalRead := ihVal hval fuel (by omega)
       have hbodyRead := ihBody hbody fuel (by omega)
       have htag := getTag4_reads Ixon.Expr.FLAG_LET
-        (if nonDep then 1 else 0) (by decide)
+        nonDep.flags (by decide)
       have hreturn := Reads.pure (Ixon.Expr.letE nonDep ty val body)
       have hafterBody := Reads.bind
         (next := fun decodedBody : Ixon.Expr =>
@@ -689,11 +735,16 @@ theorem getExprFuel_reads_single (e : Ixon.Expr) (h : SingleWireWF e)
         htyRead hafterVal
       have htail : Reads
           (Ixon.getExprFromTag (Ixon.getExprFuel fuel)
-            ⟨Ixon.Expr.FLAG_LET, if nonDep then 1 else 0⟩)
-          (wireEncode ty ++ wireEncode val ++ wireEncode body)
+            ⟨Ixon.Expr.FLAG_LET, nonDep.flags⟩)
+          ([nonDep.binder.toBits].toByteArray ++
+            wireEncode ty ++ wireEncode val ++ wireEncode body)
           (.letE nonDep ty val body) := by
-        cases nonDep <;> simpa [Ixon.getExprFromTag, Ixon.Expr.FLAG_LET,
-          ByteArray.append_assoc] using hchildren
+        simp only [Ixon.getExprFromTag, Ixon.Expr.FLAG_LET,
+          if_neg (letFlags_not_gt nonDep)]
+        simp only [ByteArray.append_assoc]
+        apply Reads.bind (getBinderContract_reads nonDep.binder)
+        simpa only [Ixon.LetContract.ofFlags?_flags, ByteArray.append_assoc,
+          ByteArray.append_empty] using hchildren
       have hall := Reads.bind
         (next := Ixon.getExprFromTag (Ixon.getExprFuel fuel)) htag htail
       simpa [Ixon.getExprFuel, wireEncode, ByteArray.append_assoc] using hall
diff --git a/Ix/Compile/Verify/ExprSpineCodec.lean b/Ix/Compile/Verify/ExprSpineCodec.lean
index 24d8588f1..75eca0cca 100644
--- a/Ix/Compile/Verify/ExprSpineCodec.lean
+++ b/Ix/Compile/Verify/ExprSpineCodec.lean
@@ -172,25 +172,25 @@ def exprListBytes (encode : Ixon.Expr → ByteArray) : List Ixon.Expr → ByteAr
   | expr :: exprs => encode expr ++ exprListBytes encode exprs
 
 def lamBinderListBytes (encode : Ixon.Expr → ByteArray) :
-    List (Ixon.Uses × Ixon.Expr) → ByteArray
+    List (Ixon.BinderContract × Ixon.Expr) → ByteArray
   | [] => ByteArray.empty
   | (uses, ty) :: binders =>
       [uses.toBits].toByteArray ++ encode ty ++
         lamBinderListBytes encode binders
 
 def allBinderListBytes (encode : Ixon.Expr → ByteArray) :
-    List (Ixon.Uses × Ixon.Owned × Ixon.Expr) → ByteArray
+    List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr) → ByteArray
   | [] => ByteArray.empty
   | (uses, owned, ty) :: binders =>
-      [uses.toBits ||| (owned.toBits <<< 2)].toByteArray ++ encode ty ++
+      [Ixon.packAllContract uses owned].toByteArray ++ encode ty ++
         allBinderListBytes encode binders
 
-def allBinderMode (uses : Ixon.Uses) (owned : Ixon.Owned) : UInt8 :=
-  uses.toBits ||| (owned.toBits <<< 2)
+def allBinderMode (uses : Ixon.BinderContract) (owned : Ixon.ValueContract) : UInt8 :=
+  Ixon.packAllContract uses owned
 
 @[simp] theorem allBinderTriple_type
-    (uses : Ixon.Uses) (owned : Ixon.Owned) (ty : Ixon.Expr) :
-    ((uses, owned, ty) : Ixon.Uses × Ixon.Owned × Ixon.Expr).2.2 = ty := by
+    (uses : Ixon.BinderContract) (owned : Ixon.ValueContract) (ty : Ixon.Expr) :
+    ((uses, owned, ty) : Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr).2.2 = ty := by
   rfl
 
 /-- Exact bytes written by the production codec when complete application
@@ -233,8 +233,9 @@ def spineWireEncode : Ixon.Expr → ByteArray
                   spineWireEncode binder.1.2.2) ++
           spineWireEncode expr.collectAllBinders.2
   | .letE nonDep ty val body =>
-      tag4Bytes Ixon.Expr.FLAG_LET (if nonDep then 1 else 0) ++
-        spineWireEncode ty ++ spineWireEncode val ++ spineWireEncode body
+      tag4Bytes Ixon.Expr.FLAG_LET nonDep.flags ++
+        ([nonDep.binder.toBits].toByteArray ++
+          (spineWireEncode ty ++ (spineWireEncode val ++ spineWireEncode body)))
   | .share idx => tag4Bytes Ixon.Expr.FLAG_SHARE idx
 termination_by expr => expr.nodeCount
 decreasing_by
@@ -303,12 +304,45 @@ theorem spineWireEncode_size_pos (expr : Ixon.Expr) :
       omega
   | letE nonDep ty val body =>
       have h := tag4Bytes_size_pos Ixon.Expr.FLAG_LET
-        (if nonDep then 1 else 0)
+        nonDep.flags
       simp only [spineWireEncode, ByteArray.size_append]
       omega
   | share idx => simpa [spineWireEncode] using
       tag4Bytes_size_pos Ixon.Expr.FLAG_SHARE idx
 
+theorem exprListBytes_size_ge_length (exprs : List Ixon.Expr) :
+    exprs.length ≤ (exprListBytes spineWireEncode exprs).size := by
+  induction exprs with
+  | nil => simp [exprListBytes]
+  | cons expr exprs ih =>
+    have hpos := spineWireEncode_size_pos expr
+    simp only [exprListBytes, ByteArray.size_append, List.length_cons]
+    omega
+
+theorem lamBinderListBytes_size_ge_length
+    (binders : List (Ixon.BinderContract × Ixon.Expr)) :
+    binders.length * 2 ≤ (lamBinderListBytes spineWireEncode binders).size := by
+  induction binders with
+  | nil => simp [lamBinderListBytes]
+  | cons binder binders ih =>
+    rcases binder with ⟨uses, ty⟩
+    have hpos := spineWireEncode_size_pos ty
+    simp only [lamBinderListBytes, ByteArray.size_append, List.length_cons,
+      List.size_toByteArray, List.length_nil]
+    omega
+
+theorem allBinderListBytes_size_ge_length
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)) :
+    binders.length * 2 ≤ (allBinderListBytes spineWireEncode binders).size := by
+  induction binders with
+  | nil => simp [allBinderListBytes]
+  | cons binder binders ih =>
+    rcases binder with ⟨uses, owned, ty⟩
+    have hpos := spineWireEncode_size_pos ty
+    simp only [allBinderListBytes, ByteArray.size_append, List.length_cons,
+      List.size_toByteArray, List.length_nil]
+    omega
+
 theorem attachFold_exprListBytes (encode : Ixon.Expr → ByteArray)
     (exprs : List Ixon.Expr) (initial : ByteArray) :
     exprs.attach.foldl
@@ -324,18 +358,18 @@ theorem attachFold_exprListBytes (encode : Ixon.Expr → ByteArray)
       ih (initial ++ encode expr)
 
 theorem attachFold_lamBinderListBytes (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Expr)) (initial : ByteArray) :
+    (binders : List (Ixon.BinderContract × Ixon.Expr)) (initial : ByteArray) :
     binders.attach.foldl
         (fun bytes binder =>
           bytes ++ [binder.1.1.toBits].toByteArray ++ encode binder.1.2)
         initial = initial ++ lamBinderListBytes encode binders := by
   change binders.attach.foldl
       (fun bytes binder =>
-        (fun bytes (value : Ixon.Uses × Ixon.Expr) =>
+        (fun bytes (value : Ixon.BinderContract × Ixon.Expr) =>
           bytes ++ [value.1.toBits].toByteArray ++ encode value.2)
           bytes binder.1) initial = _
   rw [List.foldl_attach
-    (f := fun bytes (binder : Ixon.Uses × Ixon.Expr) =>
+    (f := fun bytes (binder : Ixon.BinderContract × Ixon.Expr) =>
       bytes ++ [binder.1.toBits].toByteArray ++ encode binder.2)]
   induction binders generalizing initial with
   | nil => simp [lamBinderListBytes]
@@ -345,7 +379,7 @@ theorem attachFold_lamBinderListBytes (encode : Ixon.Expr → ByteArray)
     simp only [ByteArray.append_assoc]
 
 theorem attachFold_allBinderListBytes (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
     (initial : ByteArray) :
     binders.attach.foldl
         (fun bytes binder =>
@@ -354,12 +388,12 @@ theorem attachFold_allBinderListBytes (encode : Ixon.Expr → ByteArray)
       initial ++ allBinderListBytes encode binders := by
   change binders.attach.foldl
       (fun bytes binder =>
-        (fun bytes (value : Ixon.Uses × Ixon.Owned × Ixon.Expr) =>
+        (fun bytes (value : Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr) =>
           bytes ++ [allBinderMode value.1 value.2.1].toByteArray ++
             encode value.2.2) bytes binder.1) initial = _
   rw [List.foldl_attach
     (f := fun bytes
-      (binder : Ixon.Uses × Ixon.Owned × Ixon.Expr) =>
+      (binder : Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr) =>
       bytes ++ [allBinderMode binder.1 binder.2.1].toByteArray ++
         encode binder.2.2)]
   induction binders generalizing initial with
@@ -372,14 +406,14 @@ theorem attachFold_allBinderListBytes (encode : Ixon.Expr → ByteArray)
 def putExprList (exprs : List Ixon.Expr) : Ixon.PutM Unit :=
   exprs.foldlM (fun _ expr => Ixon.putExpr expr) ()
 
-def putLamBinderList (binders : List (Ixon.Uses × Ixon.Expr)) :
+def putLamBinderList (binders : List (Ixon.BinderContract × Ixon.Expr)) :
     Ixon.PutM Unit := do
   for binder in binders do
     Ixon.putU8 binder.1.toBits
     Ixon.putExpr binder.2
 
 def putAllBinderList
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr)) :
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)) :
     Ixon.PutM Unit := do
   for binder in binders do
     Ixon.putU8 (allBinderMode binder.1 binder.2.1)
@@ -405,7 +439,7 @@ theorem putExprList_writes (encode : Ixon.Expr → ByteArray)
     simpa [putExprList, exprListBytes] using hhead.bind (ih htail)
 
 theorem putLamBinderList_writes (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.Expr))
     (h : ∀ binder, binder ∈ binders →
       Writes (Ixon.putExpr binder.2) (encode binder.2)) :
     Writes (putLamBinderList binders)
@@ -429,7 +463,7 @@ theorem putLamBinderList_writes (encode : Ixon.Expr → ByteArray)
         (putU8_writes uses.toBits).bind (hhead.bind (ih htail))
 
 theorem putAllBinderList_writes (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
     (h : ∀ binder, binder ∈ binders →
       Writes (Ixon.putExpr binder.2.2) (encode binder.2.2)) :
     Writes (putAllBinderList binders)
@@ -458,7 +492,7 @@ theorem listFor_putExpr_eq (exprs : List Ixon.Expr) :
   simp [putExprList]
 
 theorem listFor_putLamBinders_eq
-    (binders : List (Ixon.Uses × Ixon.Expr)) :
+    (binders : List (Ixon.BinderContract × Ixon.Expr)) :
     (do
       for binder in binders do
         Ixon.putU8 binder.1.toBits
@@ -466,14 +500,14 @@ theorem listFor_putLamBinders_eq
   rfl
 
 theorem listFor_putAllBinders_eq
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr)) :
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)) :
     (do
       for binder in binders do
-        Ixon.putU8 (binder.1.toBits ||| (binder.2.1.toBits <<< 2))
+        Ixon.putU8 (Ixon.packAllContract binder.1 binder.2.1)
         Ixon.putExpr binder.2.2) = putAllBinderList binders := by
   simp [putAllBinderList, allBinderMode]
 
-theorem putLamBinderList_bind (binders : List (Ixon.Uses × Ixon.Expr))
+theorem putLamBinderList_bind (binders : List (Ixon.BinderContract × Ixon.Expr))
     (next : Ixon.PutM α) :
     (do
       putLamBinderList binders
@@ -486,14 +520,14 @@ theorem putLamBinderList_bind (binders : List (Ixon.Uses × Ixon.Expr))
   simp [putLamBinderList]
 
 theorem putAllBinderList_bind
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
     (next : Ixon.PutM α) :
     (do
       putAllBinderList binders
       next) =
     (do
       for binder in binders do
-        Ixon.putU8 (binder.1.toBits ||| (binder.2.1.toBits <<< 2))
+        Ixon.putU8 (Ixon.packAllContract binder.1 binder.2.1)
         Ixon.putExpr binder.2.2
       next) := by
   simp [putAllBinderList, allBinderMode]
@@ -507,7 +541,7 @@ theorem putAllBinderList_bind
 
 @[simp] theorem attachFold_lamBinderListBytes_empty
     (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Expr)) :
+    (binders : List (Ixon.BinderContract × Ixon.Expr)) :
     binders.attach.foldl
         (fun bytes binder =>
           bytes ++ [binder.1.1.toBits].toByteArray ++ encode binder.1.2)
@@ -517,7 +551,7 @@ theorem putAllBinderList_bind
 
 @[simp] theorem attachFold_allBinderListBytes_empty
     (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr)) :
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)) :
     binders.attach.foldl
         (fun bytes binder =>
           bytes ++ [allBinderMode binder.1.1 binder.1.2.1].toByteArray ++
@@ -609,11 +643,13 @@ theorem putExpr_writes_spine (expr : Ixon.Expr) (h : expr.wireWF) :
   | letE nonDep ty val body =>
     obtain ⟨hty, hval, hbody⟩ := h
     have hwrite :=
-      (putTag4_writes Ixon.Expr.FLAG_LET (if nonDep then 1 else 0)).bind
-        ((putExpr_writes_spine ty hty).bind
-          ((putExpr_writes_spine val hval).bind
-            (putExpr_writes_spine body hbody)))
-    simpa [Ixon.putExpr, spineWireEncode, ByteArray.append_assoc] using hwrite
+      (putTag4_writes Ixon.Expr.FLAG_LET nonDep.flags).bind
+        ((putU8_writes nonDep.binder.toBits).bind
+          ((putExpr_writes_spine ty hty).bind
+            ((putExpr_writes_spine val hval).bind
+              (putExpr_writes_spine body hbody))))
+    simpa [Ixon.putExpr, Ixon.putBinderContract, spineWireEncode,
+      ByteArray.append_assoc] using hwrite
   | share idx =>
     simpa [Ixon.putExpr, spineWireEncode] using
       putTag4_writes Ixon.Expr.FLAG_SHARE idx
@@ -655,7 +691,7 @@ theorem spineWireEncode_app (fn arg : Ixon.Expr) :
   simp only [spineWireEncode]
   rw [attachFold_exprListBytes_empty]
 
-theorem spineWireEncode_lam (uses : Ixon.Uses) (ty body : Ixon.Expr) :
+theorem spineWireEncode_lam (uses : Ixon.BinderContract) (ty body : Ixon.Expr) :
     spineWireEncode (.lam uses ty body) =
       tag4Bytes Ixon.Expr.FLAG_LAM
           (Ixon.Expr.lam uses ty body).collectLamBinders.1.length.toUInt64 ++
@@ -666,7 +702,7 @@ theorem spineWireEncode_lam (uses : Ixon.Uses) (ty body : Ixon.Expr) :
   simp only [spineWireEncode]
   rw [attachFold_lamBinderListBytes_empty]
 
-theorem spineWireEncode_all (uses : Ixon.Uses) (owned : Ixon.Owned)
+theorem spineWireEncode_all (uses : Ixon.BinderContract) (owned : Ixon.ValueContract)
     (ty body : Ixon.Expr) :
     spineWireEncode (.all uses owned ty body) =
       tag4Bytes Ixon.Expr.FLAG_ALL
@@ -693,8 +729,8 @@ theorem exprListBytes_member_size_le (encode : Ixon.Expr → ByteArray)
 
 theorem lamBinderListBytes_member_size_le
     (encode : Ixon.Expr → ByteArray)
-    {binder : Ixon.Uses × Ixon.Expr}
-    {binders : List (Ixon.Uses × Ixon.Expr)} (hmem : binder ∈ binders) :
+    {binder : Ixon.BinderContract × Ixon.Expr}
+    {binders : List (Ixon.BinderContract × Ixon.Expr)} (hmem : binder ∈ binders) :
     (encode binder.2).size ≤
       (lamBinderListBytes encode binders).size := by
   induction binders with
@@ -710,8 +746,8 @@ theorem lamBinderListBytes_member_size_le
 
 theorem allBinderListBytes_member_size_le
     (encode : Ixon.Expr → ByteArray)
-    {binder : Ixon.Uses × Ixon.Owned × Ixon.Expr}
-    {binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr)}
+    {binder : Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr}
+    {binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)}
     (hmem : binder ∈ binders) :
     (encode binder.2.2).size ≤
       (allBinderListBytes encode binders).size := by
@@ -749,13 +785,9 @@ theorem getExprAppArgs_reads (getm : Ixon.GetM Ixon.Expr)
     have hrest := ih (.app base expr) htail
     simpa [Ixon.getExprAppArgs, exprListBytes] using hhead.bind hrest
 
-@[simp] theorem uses_ofBits_toBits (uses : Ixon.Uses) :
-    Ixon.Uses.ofBits? uses.toBits = some uses := by
-  cases uses <;> rfl
-
 theorem getExprLamBinders_reads (getm : Ixon.GetM Ixon.Expr)
     (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.Expr))
     (h : ∀ binder, binder ∈ binders →
       Reads getm (encode binder.2) binder.2) :
     Reads (Ixon.getExprLamBinders getm binders.length)
@@ -763,7 +795,7 @@ theorem getExprLamBinders_reads (getm : Ixon.GetM Ixon.Expr)
   induction binders with
   | nil =>
     simpa [Ixon.getExprLamBinders, lamBinderListBytes] using
-      (Reads.pure ([] : List (Ixon.Uses × Ixon.Expr)))
+      (Reads.pure ([] : List (Ixon.BinderContract × Ixon.Expr)))
   | cons binder binders ih =>
     rcases binder with ⟨uses, ty⟩
     have hty := h (uses, ty) (by simp)
@@ -772,43 +804,31 @@ theorem getExprLamBinders_reads (getm : Ixon.GetM Ixon.Expr)
       intro tail hmem
       exact h tail (by simp [hmem])
     have hreturn := Reads.pure
-      ((uses, ty) :: binders : List (Ixon.Uses × Ixon.Expr))
+      ((uses, ty) :: binders : List (Ixon.BinderContract × Ixon.Expr))
     have hafterTail := Reads.bind
-      (next := fun tail : List (Ixon.Uses × Ixon.Expr) =>
+      (next := fun tail : List (Ixon.BinderContract × Ixon.Expr) =>
         (pure ((uses, ty) :: tail) :
-          Ixon.GetM (List (Ixon.Uses × Ixon.Expr))))
+          Ixon.GetM (List (Ixon.BinderContract × Ixon.Expr))))
       (ih htail) hreturn
     have hafterTy := Reads.bind
       (next := fun decodedTy : Ixon.Expr => do
         let tail ← Ixon.getExprLamBinders getm binders.length
         return (uses, decodedTy) :: tail)
       hty hafterTail
-    have hafterMode : Reads
-        (do
-          let some decodedUses := Ixon.Uses.ofBits? uses.toBits
-            | throw s!"getExpr: invalid lambda mode {uses.toBits}"
-          let decodedTy ← getm
-          let tail ← Ixon.getExprLamBinders getm binders.length
-          return (decodedUses, decodedTy) :: tail)
-        (encode ty ++ lamBinderListBytes encode binders)
-        ((uses, ty) :: binders) := by
-      simpa using hafterTy
     have hall := Reads.bind
-      (next := fun mode : UInt8 => do
-        let some decodedUses := Ixon.Uses.ofBits? mode
-          | throw s!"getExpr: invalid lambda mode {mode}"
+      (next := fun decodedUses : Ixon.BinderContract => do
         let decodedTy ← getm
         let tail ← Ixon.getExprLamBinders getm binders.length
         return (decodedUses, decodedTy) :: tail)
-      (getU8_reads uses.toBits) hafterMode
+      (getBinderContract_reads uses) hafterTy
     rw [Ixon.getExprLamBinders.eq_def, lamBinderListBytes]
     simp only [List.length_cons]
     rw [ByteArray.append_assoc]
-    exact hall
+    simpa only [ByteArray.append_empty] using hall
 
 theorem getExprAllBinders_reads (getm : Ixon.GetM Ixon.Expr)
     (encode : Ixon.Expr → ByteArray)
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
     (h : ∀ binder, binder ∈ binders →
       Reads getm (encode binder.2.2) binder.2.2) :
     Reads (Ixon.getExprAllBinders getm binders.length)
@@ -817,19 +837,11 @@ theorem getExprAllBinders_reads (getm : Ixon.GetM Ixon.Expr)
   | nil =>
     simpa [Ixon.getExprAllBinders, allBinderListBytes] using
       (Reads.pure
-        ([] : List (Ixon.Uses × Ixon.Owned × Ixon.Expr)))
+        ([] : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr)))
   | cons binder binders ih =>
     rcases binder with ⟨uses, owned, ty⟩
     let mode := allBinderMode uses owned
     have hfields := forallMode_fields uses owned
-    obtain ⟨hmodeLe, huses, howned⟩ := hfields
-    change mode ≤ 7 at hmodeLe
-    change Ixon.Uses.ofBits? (mode &&& 0x03) = some uses at huses
-    change Ixon.Owned.ofBits? ((mode >>> 2) &&& 0x01) = some owned at howned
-    have hmodeNotGt : ¬ mode > 7 := by
-      simp only [UInt8.le_iff_toNat_le] at hmodeLe
-      simp only [UInt8.lt_iff_toNat_lt]
-      omega
     have hty := h (uses, owned, ty) (by simp)
     have htail : ∀ tail, tail ∈ binders →
         Reads getm (encode tail.2.2) tail.2.2 := by
@@ -837,11 +849,11 @@ theorem getExprAllBinders_reads (getm : Ixon.GetM Ixon.Expr)
       exact h tail (by simp [hmem])
     have hreturn := Reads.pure
       ((uses, owned, ty) :: binders :
-        List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+        List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
     have hafterTail := Reads.bind
-      (next := fun tail : List (Ixon.Uses × Ixon.Owned × Ixon.Expr) =>
+      (next := fun tail : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr) =>
         (pure ((uses, owned, ty) :: tail) :
-          Ixon.GetM (List (Ixon.Uses × Ixon.Owned × Ixon.Expr))))
+          Ixon.GetM (List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))))
       (ih htail) hreturn
     have hafterTy := Reads.bind
       (next := fun decodedTy : Ixon.Expr => do
@@ -850,28 +862,18 @@ theorem getExprAllBinders_reads (getm : Ixon.GetM Ixon.Expr)
       hty hafterTail
     have hafterMode : Reads
         (do
-          if mode > 7 then
-            throw s!"getExpr: invalid forall mode {mode}"
-          let some decodedUses := Ixon.Uses.ofBits? (mode &&& 0x03)
-            | throw s!"getExpr: invalid forall usage mode {mode}"
-          let some decodedOwned :=
-              Ixon.Owned.ofBits? ((mode >>> 2) &&& 0x01)
-            | throw s!"getExpr: invalid forall ownership mode {mode}"
+          let some (decodedUses, decodedOwned) := Ixon.unpackAllContract? mode
+            | throw s!"getExpr: invalid forall contract {mode}"
           let decodedTy ← getm
           let tail ← Ixon.getExprAllBinders getm binders.length
           return (decodedUses, decodedOwned, decodedTy) :: tail)
         (encode ty ++ allBinderListBytes encode binders)
         ((uses, owned, ty) :: binders) := by
-      simpa [hmodeNotGt, huses, howned] using hafterTy
+      simpa only [mode, allBinderMode, hfields, ByteArray.append_empty] using hafterTy
     have hall := Reads.bind
       (next := fun decodedMode : UInt8 => do
-        if decodedMode > 7 then
-          throw s!"getExpr: invalid forall mode {decodedMode}"
-        let some decodedUses := Ixon.Uses.ofBits? (decodedMode &&& 0x03)
-          | throw s!"getExpr: invalid forall usage mode {decodedMode}"
-        let some decodedOwned :=
-            Ixon.Owned.ofBits? ((decodedMode >>> 2) &&& 0x01)
-          | throw s!"getExpr: invalid forall ownership mode {decodedMode}"
+        let some (decodedUses, decodedOwned) := Ixon.unpackAllContract? decodedMode
+          | throw s!"getExpr: invalid forall contract {decodedMode}"
         let decodedTy ← getm
         let tail ← Ixon.getExprAllBinders getm binders.length
         return (decodedUses, decodedOwned, decodedTy) :: tail)
@@ -903,7 +905,7 @@ theorem canonicalAppContinuation_reads (getm : Ixon.GetM Ixon.Expr)
   cases base <;> simp_all [notApp]
 
 theorem canonicalLamFinish_reads
-    (binders : List (Ixon.Uses × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.Expr))
     (base result : Ixon.Expr) (hbase : notLam base)
     (hreconstruct : binders.foldr
       (fun binder body => .lam binder.1 binder.2 body) base = result) :
@@ -918,7 +920,7 @@ theorem canonicalLamFinish_reads
   cases base <;> simp_all [notLam] <;> apply Reads.pure
 
 theorem canonicalAllFinish_reads
-    (binders : List (Ixon.Uses × Ixon.Owned × Ixon.Expr))
+    (binders : List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr))
     (base result : Ixon.Expr) (hbase : notAll base)
     (hreconstruct : binders.foldr
       (fun binder body => .all binder.1 binder.2.1 binder.2.2 body)
@@ -983,11 +985,15 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
         (next := fun decoded : List UInt64 =>
           (pure (Ixon.Expr.ref refIdx decoded.toArray) :
             Ixon.GetM Ixon.Expr)) hunivs hreturn
+      have hcheckedUnivs := Reads.checkCount univs.size.toUInt64 1
+        (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList)
+        hafterUnivs
       have htail0 := Reads.bind
         (next := fun decoded : Ixon.Tag0 => do
+          Ixon.checkCount univs.size.toUInt64
           let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length
           return Ixon.Expr.ref decoded.size decodedUnivs.toArray)
-        hidx hafterUnivs
+        hidx hcheckedUnivs
       have hparsed : Reads
           (Ixon.getExprFromTag (Ixon.getExprFuel fuel)
             ⟨Ixon.Expr.FLAG_REF, univs.size.toUInt64⟩)
@@ -1014,11 +1020,15 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
         (next := fun decoded : List UInt64 =>
           (pure (Ixon.Expr.recur recIdx decoded.toArray) :
             Ixon.GetM Ixon.Expr)) hunivs hreturn
+      have hcheckedUnivs := Reads.checkCount univs.size.toUInt64 1
+        (by simpa [hcount] using tag0ListBytes_size_ge_length univs.toList)
+        hafterUnivs
       have htail0 := Reads.bind
         (next := fun decoded : Ixon.Tag0 => do
+          Ixon.checkCount univs.size.toUInt64
           let decodedUnivs ← Ixon.getTag0Sizes univs.toList.length
           return Ixon.Expr.recur decoded.size decodedUnivs.toArray)
-        hidx hafterUnivs
+        hidx hcheckedUnivs
       have hparsed : Reads
           (Ixon.getExprFromTag (Ixon.getExprFuel fuel)
             ⟨Ixon.Expr.FLAG_REC, univs.size.toUInt64⟩)
@@ -1143,6 +1153,11 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
           whole := by
         simp only [Ixon.getExprFromTag, Ixon.Expr.FLAG_APP, hcountBeq,
           Bool.false_eq_true, if_false]
+        apply Reads.checkCount args.length.toUInt64 1
+          (by
+            have hbytes := exprListBytes_size_ge_length args
+            simp only [hcount, ByteArray.size_append, Nat.mul_one]
+            omega)
         rw [hcount]
         exact Reads.bind
           (next := fun decodedBase : Ixon.Expr => do
@@ -1242,7 +1257,7 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
           (lamBinderListBytes spineWireEncode binders ++
             spineWireEncode base) whole := by
         exact Reads.bind
-          (next := fun decodedBinders : List (Ixon.Uses × Ixon.Expr) => do
+          (next := fun decodedBinders : List (Ixon.BinderContract × Ixon.Expr) => do
             let decodedBase ← Ixon.getExprFuel fuel
             match decodedBase with
             | .lam .. => throw "getExpr: non-canonical lam telescope"
@@ -1257,6 +1272,11 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
             spineWireEncode base) whole := by
         simp only [Ixon.getExprFromTag, Ixon.Expr.FLAG_LAM, hcountBeq,
           Bool.false_eq_true, if_false]
+        apply Reads.checkCount binders.length.toUInt64 2
+          (by
+            have hbytes := lamBinderListBytes_size_ge_length binders
+            simp only [hcount, ByteArray.size_append]
+            omega)
         rw [hcount]
         exact hparsed0
       have htag := getTag4_reads Ixon.Expr.FLAG_LAM binders.length.toUInt64
@@ -1356,7 +1376,7 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
             spineWireEncode base) whole := by
         exact Reads.bind
           (next := fun decodedBinders :
-              List (Ixon.Uses × Ixon.Owned × Ixon.Expr) => do
+              List (Ixon.BinderContract × Ixon.ValueContract × Ixon.Expr) => do
             let decodedBase ← Ixon.getExprFuel fuel
             match decodedBase with
             | .all .. => throw "getExpr: non-canonical all telescope"
@@ -1372,6 +1392,11 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
             spineWireEncode base) whole := by
         simp only [Ixon.getExprFromTag, Ixon.Expr.FLAG_ALL, hcountBeq,
           Bool.false_eq_true, if_false]
+        apply Reads.checkCount binders.length.toUInt64 2
+          (by
+            have hbytes := allBinderListBytes_size_ge_length binders
+            simp only [hcount, ByteArray.size_append]
+            omega)
         rw [hcount]
         exact hparsed0
       have htag := getTag4_reads Ixon.Expr.FLAG_ALL binders.length.toUInt64
@@ -1383,17 +1408,19 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
     | letE nonDep ty val body =>
       obtain ⟨hty, hval, hbody⟩ := h
       have hsizes :
-          (tag4Bytes Ixon.Expr.FLAG_LET (if nonDep then 1 else 0)).size +
+          (tag4Bytes Ixon.Expr.FLAG_LET nonDep.flags).size + 1 +
               (spineWireEncode ty).size + (spineWireEncode val).size +
                 (spineWireEncode body).size ≤ fuel + 1 := by
-        simpa only [spineWireEncode, ByteArray.size_append] using hfuel
+        simpa only [spineWireEncode, ByteArray.size_append,
+          List.size_toByteArray, List.length_cons, List.length_nil,
+          Nat.zero_add, Nat.add_assoc] using hfuel
       have htagPos := tag4Bytes_size_pos Ixon.Expr.FLAG_LET
-        (if nonDep then 1 else 0)
+        nonDep.flags
       have htyRead := getExprFuel_reads_spine ty hty fuel (by omega)
       have hvalRead := getExprFuel_reads_spine val hval fuel (by omega)
       have hbodyRead := getExprFuel_reads_spine body hbody fuel (by omega)
       have htag := getTag4_reads Ixon.Expr.FLAG_LET
-        (if nonDep then 1 else 0) (by decide)
+        nonDep.flags (by decide)
       have hreturn := Reads.pure (Ixon.Expr.letE nonDep ty val body)
       have hafterBody := Reads.bind
         (next := fun decodedBody : Ixon.Expr =>
@@ -1412,11 +1439,15 @@ theorem getExprFuel_reads_spine (expr : Ixon.Expr) (h : expr.wireWF)
         htyRead hafterVal
       have hparsed : Reads
           (Ixon.getExprFromTag (Ixon.getExprFuel fuel)
-            ⟨Ixon.Expr.FLAG_LET, if nonDep then 1 else 0⟩)
-          (spineWireEncode ty ++ spineWireEncode val ++
-            spineWireEncode body) (.letE nonDep ty val body) := by
-        cases nonDep <;> simpa [Ixon.getExprFromTag, Ixon.Expr.FLAG_LET,
-          ByteArray.append_assoc] using hchildren
+            ⟨Ixon.Expr.FLAG_LET, nonDep.flags⟩)
+          ([nonDep.binder.toBits].toByteArray ++
+            spineWireEncode ty ++ spineWireEncode val ++ spineWireEncode body) (.letE nonDep ty val body) := by
+        simp only [Ixon.getExprFromTag, Ixon.Expr.FLAG_LET,
+          if_neg (letFlags_not_gt nonDep)]
+        simp only [ByteArray.append_assoc]
+        apply Reads.bind (getBinderContract_reads nonDep.binder)
+        simpa only [Ixon.LetContract.ofFlags?_flags, ByteArray.append_assoc,
+          ByteArray.append_empty] using hchildren
       have hall := Reads.bind
         (next := Ixon.getExprFromTag (Ixon.getExprFuel fuel)) htag hparsed
       simpa [Ixon.getExprFuel, spineWireEncode,
diff --git a/Ix/Compile/Verify/IxonValue.lean b/Ix/Compile/Verify/IxonValue.lean
index 84358438e..18f489ed7 100644
--- a/Ix/Compile/Verify/IxonValue.lean
+++ b/Ix/Compile/Verify/IxonValue.lean
@@ -3,7 +3,7 @@ import Lean4Lean.Theory.Literals
 import Lean4Lean.Theory.Typing.Env
 
 /-!
-# Ixon v2 expressions and Lean4Lean values
+# Ixon v3 expressions and Lean4Lean values
 
 This is the first compiler-facing semantic boundary.  It interprets an Ixon
 expression directly as a Lean4Lean `VExpr`; it does not run Ix.Tc and does not
@@ -13,7 +13,7 @@ The relation is table-aware.  It resolves universe, reference, mutual-member,
 sharing, and literal indices against an explicit immutable context.  A cyclic
 sharing table has no finite derivation.  Lambda usage and forall
 usage/ownership are intentionally absent from the semantic premises: ordinary
-Lean compilation inhabits `.many`/`.shared`, while v2 annotations remain
+Lean compilation inhabits `.many`/`.shared`, while v3 contracts remain
 available to later substructural passes without changing the Lean meaning.
 -/
 
@@ -116,19 +116,19 @@ inductive IxonExprRel (venv : VEnv) (catalog : Catalog) (dctx : DecodeCtx)
     IxonExprRel venv catalog dctx trProj locals fn fn' →
     IxonExprRel venv catalog dctx trProj locals arg arg' →
     IxonExprRel venv catalog dctx trProj locals (.app fn arg) (.app fn' arg')
-  | lam {locals : List VExpr} {uses : Ixon.Uses} {ty body : Ixon.Expr}
+  | lam {locals : List VExpr} {uses : Ixon.BinderContract} {ty body : Ixon.Expr}
       {ty' body' : VExpr} :
     IxonExprRel venv catalog dctx trProj locals ty ty' →
     IxonExprRel venv catalog dctx trProj (ty' :: locals) body body' →
     IxonExprRel venv catalog dctx trProj locals (.lam uses ty body)
       (.lam ty' body')
-  | all {locals : List VExpr} {uses : Ixon.Uses} {owned : Ixon.Owned}
+  | all {locals : List VExpr} {uses : Ixon.BinderContract} {owned : Ixon.ValueContract}
       {ty body : Ixon.Expr} {ty' body' : VExpr} :
     IxonExprRel venv catalog dctx trProj locals ty ty' →
     IxonExprRel venv catalog dctx trProj (ty' :: locals) body body' →
     IxonExprRel venv catalog dctx trProj locals (.all uses owned ty body)
       (.forallE ty' body')
-  | letE {locals : List VExpr} {nonDep : Bool} {ty val body : Ixon.Expr}
+  | letE {locals : List VExpr} {nonDep : Ixon.LetContract} {ty val body : Ixon.Expr}
       {ty' val' body' : VExpr} :
     IxonExprRel venv catalog dctx trProj locals ty ty' →
     IxonExprRel venv catalog dctx trProj locals val val' →
@@ -192,7 +192,7 @@ theorem mono {venv venv' : VEnv} (henv : venv ≤ venv')
 
 end IxonExprRel
 
-/-- Erase v2 substructural annotations into the conservative Lean fragment. -/
+/-- Erase v3 contracts into the conservative Lean fragment. -/
 def eraseBinderModes : Ixon.Expr → Ixon.Expr
   | .sort idx => .sort idx
   | .var idx => .var idx
@@ -205,19 +205,19 @@ def eraseBinderModes : Ixon.Expr → Ixon.Expr
   | .lam _ ty body => .leanLam (eraseBinderModes ty) (eraseBinderModes body)
   | .all _ _ ty body => .leanAll (eraseBinderModes ty) (eraseBinderModes body)
   | .letE nonDep ty val body =>
-    .letE nonDep (eraseBinderModes ty) (eraseBinderModes val)
+    .leanLet nonDep.nonDep (eraseBinderModes ty) (eraseBinderModes val)
       (eraseBinderModes body)
   | .share idx => .share idx
 
 @[simp] theorem eraseModes_idem (expr : Ixon.Expr) :
     eraseBinderModes (eraseBinderModes expr) = eraseBinderModes expr := by
   induction expr <;>
-    simp [eraseBinderModes, Ixon.Expr.leanLam, Ixon.Expr.leanAll, *]
+    simp [eraseBinderModes, Ixon.Expr.leanLam, Ixon.Expr.leanAll, Ixon.Expr.leanLet, Ixon.LetContract.lean, *]
 
 @[simp] theorem leanFragment_eraseModes (expr : Ixon.Expr) :
     (eraseBinderModes expr).leanFragment = true := by
   induction expr <;>
-    simp [eraseBinderModes, Ixon.Expr.leanLam, Ixon.Expr.leanAll,
+    simp [eraseBinderModes, Ixon.Expr.leanLam, Ixon.Expr.leanAll, Ixon.Expr.leanLet, Ixon.LetContract.lean,
       Ixon.Expr.leanFragment, *]
 
 /-- A conservative-fragment expression is unchanged by mode erasure. -/
@@ -231,19 +231,24 @@ theorem eraseBinderModes_eq_self_of_leanFragment {expr : Ixon.Expr}
   | app fn arg ihfn iharg =>
     simp only [Ixon.Expr.leanFragment, Bool.and_eq_true] at h
     simp [eraseBinderModes, ihfn h.1, iharg h.2]
-  | lam uses ty body ihty ihbody =>
-    cases uses <;>
-      simp_all [Ixon.Expr.leanFragment, eraseBinderModes, Ixon.Expr.leanLam]
-  | all uses owned ty body ihty ihbody =>
-    cases uses <;> cases owned <;>
-      simp_all [Ixon.Expr.leanFragment, eraseBinderModes, Ixon.Expr.leanAll]
-  | letE nonDep ty val body ihty ihval ihbody =>
-    simp only [Ixon.Expr.leanFragment, Bool.and_eq_true] at h
-    simp [eraseBinderModes, ihty h.1.1, ihval h.1.2, ihbody h.2]
+  | lam contract ty body ihty ihbody =>
+    simp only [Ixon.Expr.leanFragment, Bool.and_eq_true, beq_iff_eq] at h
+    rcases h with ⟨⟨rfl, hty⟩, hbody⟩
+    simp [eraseBinderModes, Ixon.Expr.leanLam, ihty hty, ihbody hbody]
+  | all contract result ty body ihty ihbody =>
+    simp only [Ixon.Expr.leanFragment, Bool.and_eq_true, beq_iff_eq] at h
+    rcases h with ⟨⟨⟨rfl, rfl⟩, hty⟩, hbody⟩
+    simp [eraseBinderModes, Ixon.Expr.leanAll, ihty hty, ihbody hbody]
+  | letE contract ty val body ihty ihval ihbody =>
+    rcases contract with ⟨nonDep, kind, binder⟩
+    simp only [Ixon.Expr.leanFragment, Bool.and_eq_true, beq_iff_eq] at h
+    rcases h with ⟨⟨⟨⟨rfl, rfl⟩, hty⟩, hval⟩, hbody⟩
+    simp [eraseBinderModes, Ixon.Expr.leanLet, Ixon.LetContract.lean,
+      ihty hty, ihval hval, ihbody hbody]
 
 namespace IxonExprRel
 
-/-- Erasing v2 modes preserves every direct Theory value derivation. -/
+/-- Erasing v3 contracts preserves every direct Theory value derivation. -/
 theorem eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx}
     {trProj : ProjectionRel} {uvars : Nat} {locals : List VExpr}
     {expr : Ixon.Expr} {value : VExpr}
@@ -268,7 +273,7 @@ theorem eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx}
   | share href hexp _ => exact .share href hexp
 
 /-- A derivation for the conservative erasure can be decorated with the
-original v2 modes.  No semantic evidence is invented or discarded. -/
+original v3 contracts.  No semantic evidence is invented or discarded. -/
 theorem of_eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx}
     {trProj : ProjectionRel} {uvars : Nat} {locals : List VExpr}
     {expr : Ixon.Expr} {value : VExpr}
@@ -296,7 +301,7 @@ theorem of_eraseModes {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx}
     | letE hty hval hbody =>
       exact .letE (ihty hty) (ihval hval) (ihbody hbody)
 
-/-- V2 annotations are semantically inert at the Lean compiler boundary. -/
+/-- V3 contracts are semantically inert at the Lean compiler boundary. -/
 theorem eraseModes_iff {venv : VEnv} {catalog : Catalog} {dctx : DecodeCtx}
     {trProj : ProjectionRel} {uvars : Nat} {locals : List VExpr}
     {expr : Ixon.Expr} {value : VExpr} :
diff --git a/Ix/Compile/Verify/MutualConstantCodec.lean b/Ix/Compile/Verify/MutualConstantCodec.lean
index eb9c0c6c1..d3d001e8f 100644
--- a/Ix/Compile/Verify/MutualConstantCodec.lean
+++ b/Ix/Compile/Verify/MutualConstantCodec.lean
@@ -25,6 +25,17 @@ def constructorBytes (constructor : Ixon.Constructor) : ByteArray :=
       tag0Bytes constructor.params ++ tag0Bytes constructor.fields ++
         Ix.Compile.Verify.Codec.Ixon.Expr.spineWireEncode constructor.typ
 
+theorem constructorBytes_size_ge (constructor : Ixon.Constructor) :
+    6 ≤ (constructorBytes constructor).size := by
+  have hl := Expr.tag0Bytes_size_pos constructor.lvls
+  have hc := Expr.tag0Bytes_size_pos constructor.cidx
+  have hp := Expr.tag0Bytes_size_pos constructor.params
+  have hf := Expr.tag0Bytes_size_pos constructor.fields
+  have ht := Expr.spineWireEncode_size_pos constructor.typ
+  simp only [constructorBytes, ByteArray.size_append, List.size_toByteArray,
+    List.length_cons, List.length_nil]
+  omega
+
 def ConstructorWireWF (constructor : Ixon.Constructor) : Prop :=
   Ixon.Expr.wireWF constructor.typ
 
@@ -45,11 +56,7 @@ theorem putConstructor_writes (constructor : Ixon.Constructor)
 theorem getConstructor_reads (constructor : Ixon.Constructor)
     (h : ConstructorWireWF constructor) :
     Reads Ixon.getConstructor (constructorBytes constructor) constructor := by
-  have hbool := getU8_reads (if constructor.isUnsafe then 1 else 0)
-  have hdecode :
-      (((if constructor.isUnsafe then 1 else 0) : UInt8) != 0) =
-        constructor.isUnsafe := by
-    cases constructor.isUnsafe <;> decide
+  have hbool := getBool_reads constructor.isUnsafe
   have hlvls := getTag0_reads constructor.lvls
   have hcidx := getTag0_reads constructor.cidx
   have hparams := getTag0_reads constructor.params
@@ -93,8 +100,7 @@ theorem getConstructor_reads (constructor : Ixon.Constructor)
         Ixon.Constructor))
     hlvls hafterCidx
   have hall := Reads.bind
-    (next := fun encodedUnsafe : UInt8 => do
-      let isUnsafe := encodedUnsafe != 0
+    (next := fun isUnsafe : Bool => do
       let lvls := (← Ixon.getTag0).size
       let cidx := (← Ixon.getTag0).size
       let params := (← Ixon.getTag0).size
@@ -102,7 +108,7 @@ theorem getConstructor_reads (constructor : Ixon.Constructor)
       let typ ← Ixon.getExpr
       return (⟨isUnsafe, lvls, cidx, params, fields, typ⟩ :
         Ixon.Constructor))
-    hbool (by simpa [hdecode] using hafterLvls)
+    hbool hafterLvls
   simpa [Ixon.getConstructor, constructorBytes,
     ByteArray.append_assoc] using hall
 
@@ -127,10 +133,10 @@ theorem getConstructorArray_reads (constructors : Array Ixon.Constructor)
 def inductiveFlags (inductiveInfo : Ixon.Inductive) : UInt8 :=
   Ixon.packBools [inductiveInfo.isUnsafe]
 
-theorem unpackInductiveFlags_pack (isUnsafe : Bool) :
-    let bools := Ixon.unpackBools 1 (Ixon.packBools [isUnsafe])
-    bools[0]! = isUnsafe := by
-  cases isUnsafe <;> decide
+theorem inductiveFlags_eq (inductiveInfo : Ixon.Inductive) :
+    inductiveFlags inductiveInfo = (if inductiveInfo.isUnsafe then 1 else 0) := by
+  unfold inductiveFlags
+  cases inductiveInfo.isUnsafe <;> decide
 
 def inductiveBytes (inductiveInfo : Ixon.Inductive) : ByteArray :=
   [inductiveFlags inductiveInfo].toByteArray ++
@@ -164,6 +170,7 @@ theorem putInductive_writes (inductiveInfo : Ixon.Inductive)
 def getInductiveConstructors (isUnsafe : Bool) (lvls params indices : UInt64)
     (typ : Ixon.Expr) : Ixon.GetM Ixon.Inductive := do
   let count := (← Ixon.getTag0).size.toNat
+  Ixon.checkCount count.toUInt64 6
   let mut constructors : Array Ixon.Constructor := #[]
   for _ in [0:count] do
     constructors := constructors.push (← Ixon.getConstructor)
@@ -176,12 +183,9 @@ def getInductiveAfterFlags (isUnsafe : Bool) : Ixon.GetM Ixon.Inductive := do
   let typ ← Ixon.getExpr
   getInductiveConstructors isUnsafe lvls params indices typ
 
-def getInductiveFromFlags (flags : UInt8) : Ixon.GetM Ixon.Inductive :=
-  let bools := Ixon.unpackBools 1 flags
-  getInductiveAfterFlags bools[0]!
-
 theorem getInductive_eq :
-    Ixon.getInductive = (Ixon.getU8 >>= getInductiveFromFlags) := by
+    Ixon.getInductive =
+      ((Ixon.Serialize.get (α := Bool)) >>= getInductiveAfterFlags) := by
   rfl
 
 theorem getInductiveConstructors_reads (inductiveInfo : Ixon.Inductive)
@@ -204,15 +208,22 @@ theorem getInductiveConstructors_reads (inductiveInfo : Ixon.Inductive)
     hconstructors hreturn
   have htail : Reads
       (do
+        Ixon.checkCount inductiveInfo.ctors.size.toUInt64.toNat.toUInt64 6
         let mut constructors : Array Ixon.Constructor := #[]
         for _ in [0:inductiveInfo.ctors.size.toUInt64.toNat] do
           constructors := constructors.push (← Ixon.getConstructor)
         return ({ inductiveInfo with ctors := constructors } : Ixon.Inductive))
       (listBytes constructorBytes inductiveInfo.ctors.toList)
       inductiveInfo := by
+    apply Reads.checkCount _ 6
+      (by
+        simpa [hdecode] using
+          listBytes_size_ge constructorBytes 6 inductiveInfo.ctors.toList
+            constructorBytes_size_ge)
     simpa [getMany, hdecode] using hafterConstructors
   have hall := Reads.bind
     (next := fun count : Ixon.Tag0 => do
+      Ixon.checkCount count.size.toNat.toUInt64 6
       let mut constructors : Array Ixon.Constructor := #[]
       for _ in [0:count.size.toNat] do
         constructors := constructors.push (← Ixon.getConstructor)
@@ -266,20 +277,11 @@ theorem getInductiveAfterFlags_reads (inductiveInfo : Ixon.Inductive)
 theorem getInductive_reads (inductiveInfo : Ixon.Inductive)
     (h : InductiveWireWF inductiveInfo) :
     Reads Ixon.getInductive (inductiveBytes inductiveInfo) inductiveInfo := by
-  have hflags := getU8_reads (inductiveFlags inductiveInfo)
-  have hdecode := unpackInductiveFlags_pack inductiveInfo.isUnsafe
+  have hflags := getBool_reads inductiveInfo.isUnsafe
   have htail := getInductiveAfterFlags_reads inductiveInfo h
-  have htail' : Reads (getInductiveFromFlags (inductiveFlags inductiveInfo))
-      (tag0Bytes inductiveInfo.lvls ++ tag0Bytes inductiveInfo.params ++
-        tag0Bytes inductiveInfo.indices ++
-          Ix.Compile.Verify.Codec.Ixon.Expr.spineWireEncode inductiveInfo.typ ++
-            tag0Bytes inductiveInfo.ctors.size.toUInt64 ++
-              listBytes constructorBytes inductiveInfo.ctors.toList)
-      inductiveInfo := by
-    simpa [getInductiveFromFlags, inductiveFlags, hdecode] using htail
-  have hall := Reads.bind (next := getInductiveFromFlags) hflags htail'
+  have hall := Reads.bind (next := getInductiveAfterFlags) hflags htail
   rw [getInductive_eq]
-  simpa [inductiveBytes, ByteArray.append_assoc] using hall
+  simpa [inductiveBytes, inductiveFlags_eq, ByteArray.append_assoc] using hall
 
 inductive MutConstWireWF : Ixon.MutConst → Prop where
   | defn {definition : Ixon.Definition} :
diff --git a/Ix/Compile/Verify/RecursorConstantCodec.lean b/Ix/Compile/Verify/RecursorConstantCodec.lean
index 19853575c..fb251920c 100644
--- a/Ix/Compile/Verify/RecursorConstantCodec.lean
+++ b/Ix/Compile/Verify/RecursorConstantCodec.lean
@@ -22,6 +22,24 @@ def recursorRuleBytes (rule : Ixon.RecursorRule) : ByteArray :=
   tag0Bytes rule.fields ++
     Ix.Compile.Verify.Codec.Ixon.Expr.spineWireEncode rule.rhs
 
+theorem listBytes_size_ge (encode : α → ByteArray) (minimum : Nat) (values : List α)
+    (h : ∀ value, minimum ≤ (encode value).size) :
+    values.length * minimum ≤ (listBytes encode values).size := by
+  induction values with
+  | nil => simp [listBytes]
+  | cons value values ih =>
+    have hhead := h value
+    simp only [listBytes, ByteArray.size_append, List.length_cons, Nat.add_mul,
+      Nat.one_mul]
+    omega
+
+theorem recursorRuleBytes_size_ge (rule : Ixon.RecursorRule) :
+    2 ≤ (recursorRuleBytes rule).size := by
+  have htag := Expr.tag0Bytes_size_pos rule.fields
+  have hexpr := Expr.spineWireEncode_size_pos rule.rhs
+  simp only [recursorRuleBytes, ByteArray.size_append]
+  omega
+
 def RecursorRuleWireWF (rule : Ixon.RecursorRule) : Prop :=
   Ixon.Expr.wireWF rule.rhs
 
@@ -72,6 +90,10 @@ theorem unpackRecursorFlags_pack (k isUnsafe : Bool) :
     bools[0]! = k ∧ bools[1]! = isUnsafe := by
   cases k <;> cases isUnsafe <;> decide
 
+theorem recursorFlags_valid (k isUnsafe : Bool) :
+    ¬ Ixon.packBools [k, isUnsafe] > 3 := by
+  cases k <;> cases isUnsafe <;> decide
+
 def recursorBytes (recursor : Ixon.Recursor) : ByteArray :=
   [recursorFlags recursor].toByteArray ++
     tag0Bytes recursor.lvls ++ tag0Bytes recursor.params ++
@@ -105,6 +127,7 @@ theorem putRecursor_writes (recursor : Ixon.Recursor)
 def getRecursorRules (k isUnsafe : Bool) (lvls params indices motives minors : UInt64)
     (typ : Ixon.Expr) : Ixon.GetM Ixon.Recursor := do
   let count := (← Ixon.getTag0).size.toNat
+  Ixon.checkCount count.toUInt64 2
   let mut rules : Array Ixon.RecursorRule := #[]
   for _ in [0:count] do
     rules := rules.push (← Ixon.getRecursorRule)
@@ -119,7 +142,8 @@ def getRecursorAfterFlags (k isUnsafe : Bool) : Ixon.GetM Ixon.Recursor := do
   let typ ← Ixon.getExpr
   getRecursorRules k isUnsafe lvls params indices motives minors typ
 
-def getRecursorFromFlags (flags : UInt8) : Ixon.GetM Ixon.Recursor :=
+def getRecursorFromFlags (flags : UInt8) : Ixon.GetM Ixon.Recursor := do
+  if flags > 3 then throw "invalid recursor flags"
   let bools := Ixon.unpackBools 2 flags
   getRecursorAfterFlags bools[0]! bools[1]!
 
@@ -147,14 +171,21 @@ theorem getRecursorRules_reads (recursor : Ixon.Recursor)
     hrules hreturn
   have htail : Reads
       (do
+        Ixon.checkCount recursor.rules.size.toUInt64.toNat.toUInt64 2
         let mut rules : Array Ixon.RecursorRule := #[]
         for _ in [0:recursor.rules.size.toUInt64.toNat] do
           rules := rules.push (← Ixon.getRecursorRule)
         return ({ recursor with rules } : Ixon.Recursor))
       (listBytes recursorRuleBytes recursor.rules.toList) recursor := by
+    apply Reads.checkCount _ 2
+      (by
+        simpa [hdecode] using
+          listBytes_size_ge recursorRuleBytes 2 recursor.rules.toList
+            recursorRuleBytes_size_ge)
     simpa [getMany, hdecode] using hafterRules
   have hall := Reads.bind
     (next := fun count : Ixon.Tag0 => do
+      Ixon.checkCount count.size.toNat.toUInt64 2
       let mut rules : Array Ixon.RecursorRule := #[]
       for _ in [0:count.size.toNat] do
         rules := rules.push (← Ixon.getRecursorRule)
@@ -241,7 +272,8 @@ theorem getRecursor_reads (recursor : Ixon.Recursor)
               tag0Bytes recursor.rules.size.toUInt64 ++
                 listBytes recursorRuleBytes recursor.rules.toList)
       recursor := by
-    simpa [getRecursorFromFlags, recursorFlags, hdecode.1, hdecode.2] using htail
+    simpa [getRecursorFromFlags, recursorFlags, recursorFlags_valid,
+      hdecode.1, hdecode.2] using htail
   have hall := Reads.bind (next := getRecursorFromFlags) hflags htail'
   rw [getRecursor_eq]
   simpa [recursorBytes, ByteArray.append_assoc] using hall
diff --git a/Ix/Compile/Verify/Reference.lean b/Ix/Compile/Verify/Reference.lean
index 9a5610c02..0a8200ff8 100644
--- a/Ix/Compile/Verify/Reference.lean
+++ b/Ix/Compile/Verify/Reference.lean
@@ -142,7 +142,7 @@ def compileExprRef (ctx : RefCompileCtx) : Ix.Expr → Option Ixon.Expr
   | .forallE _ ty body _ _ =>
     return .leanAll (← compileExprRef ctx ty) (← compileExprRef ctx body)
   | .letE _ ty val body nonDep _ =>
-    return .letE nonDep (← compileExprRef ctx ty) (← compileExprRef ctx val)
+    return .leanLet nonDep (← compileExprRef ctx ty) (← compileExprRef ctx val)
       (← compileExprRef ctx body)
   | .lit literal _ => do
     let refIdx ← ctx.literalRef literal
@@ -218,7 +218,7 @@ theorem compileExprRef_spineCounts {ctx : RefCompileCtx}
   | letE _ ty value body nonDep _ ihty ihvalue ihbody =>
     simp [compileExprRef] at h
     rcases h with ⟨ty', hty, value', hvalue, body', hbody, rfl⟩
-    simp [Ixon.Expr.appCount, Ixon.Expr.lamCount, Ixon.Expr.allCount,
+    simp [Ixon.Expr.leanLet, Ixon.Expr.appCount, Ixon.Expr.lamCount, Ixon.Expr.allCount,
       sourceAppCount, sourceLamCount, sourceAllCount]
   | lit literal _ =>
     cases literal <;> simp [compileExprRef] at h <;>
@@ -342,7 +342,8 @@ theorem compileExprRef_leanFragment {ctx : RefCompileCtx}
   | letE _ ty val body nonDep _ ihty ihval ihbody =>
     simp [compileExprRef] at h
     rcases h with ⟨ty', hty, val', hval, body', hbody, rfl⟩
-    simp [Ixon.Expr.leanFragment, ihty hty, ihval hval, ihbody hbody]
+    simp [Ixon.Expr.leanLet, Ixon.LetContract.lean, Ixon.Expr.leanFragment,
+      ihty hty, ihval hval, ihbody hbody]
   | lit literal _ =>
     cases literal <;> simp [compileExprRef] at h <;>
       rcases h with ⟨idx, hidx, rfl⟩ <;> rfl
diff --git a/Ix/CompileDriver.lean b/Ix/CompileDriver.lean
index a10b8af1f..827668ce3 100644
--- a/Ix/CompileDriver.lean
+++ b/Ix/CompileDriver.lean
@@ -40,6 +40,8 @@ public import Ix.CanonM
 public import Ix.Ground
 public import Ix.CompileM
 public import Ix.AuxGen.CompileAux
+public import Ix.Compile.SourceContract.Transport
+public import Ix.Resource.Validate
 public section
 
 namespace Ix.CompileM
@@ -1018,10 +1020,29 @@ structure LeanPipelineOut where
     materialized pipeline.
 
     See the section docstring; phase timings print when `dbg` is set. -/
-def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
+def inspectSemanticSource (source : Lean.ConstantInfo) : Except String Unit := do
+  if !Ix.Compile.sourceHasSemanticContracts source then return
+  let (canonical, _) := (Ix.CanonM.canonConst source).run {}
+  let _ ← Ix.SemanticContract.inspect canonical.getCnst.type
+  match canonical with
+  | .defnInfo info => let _ ← Ix.SemanticContract.inspect info.value; pure ()
+  | .thmInfo info => let _ ← Ix.SemanticContract.inspect info.value; pure ()
+  | .opaqueInfo info => let _ ← Ix.SemanticContract.inspect info.value; pure ()
+  | .axiomInfo _ => pure ()
+  | _ => throw s!"annotated inductive/constructor/recursor transformations are unsupported: {source.name}"
+
+def compileDecoratedConsts (consts : List (Lean.Name × Lean.ConstantInfo))
     (rustRef : Option (Std.HashMap Name Address) := none)
     (numWorkers : Nat := 32) (dbg : Bool := false)
+    (resourceProfile : Option Ix.Resource.Profile := none)
     : IO (Except String LeanPipelineOut) := do
+  let annotated := consts.any fun (_, source) => Ix.Compile.sourceHasSemanticContracts source
+  for (name, source) in consts do
+    if Ix.Compile.sourceHasAnnotations source then
+      return .error s!"unresolved source binder contracts: {name}"
+    match inspectSemanticSource source with
+    | .error error => return .error error
+    | .ok _ => pure ()
   -- IX_COMPILE_DBG=1 forces phase timing + the driver's periodic memory
   -- attribution trace without threading a flag through callers.
   let dbg := dbg || (← IO.getEnv "IX_COMPILE_DBG").isSome
@@ -1142,7 +1163,15 @@ def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
       IO.println s!"  [compile-lean] {cenv.ungrounded.size} per-block compile failures"
       for (n, e) in cenv.ungrounded.toList.take 5 do
         IO.println s!"    failed: {n.pretty}: {e.take 200}"
-    -- 6. Serialize.
+    -- Semantic emission is atomic: a failed source declaration must not
+    -- disappear into an otherwise successful partial artifact.
+    if annotated || resourceProfile.isSome then
+      if !ungrounded.isEmpty || !cenv.ungrounded.isEmpty then
+        return .error "resource compilation requires the complete requested closure"
+      match Ix.Resource.validate ixonEnv (resourceProfile.getD (Ix.Resource.standardProfile ixonEnv)) with
+      | .error error => return .error error
+      | .ok _ => pure ()
+    -- 6. Serialize only after the combined validation succeeds.
     match Ixon.serEnv ixonEnv with
     | .error e => return .error s!"serEnv failed: {e}"
     | .ok bytes =>
@@ -1155,4 +1184,45 @@ def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
         blockCount := condensed.blocks.size
         digests }
 
+/-- Explicit frontend boundary: resolve occurrence contracts before
+canonicalization, then validate resources and erased types before emission. -/
+def compileLeanInput (input : Ix.Compile.CompileInput)
+    (rustRef : Option (Std.HashMap Name Address) := none)
+    (numWorkers : Nat := 32) (dbg : Bool := false)
+    (resourceProfile : Option Ix.Resource.Profile := none) :
+    IO (Except String LeanPipelineOut) := do
+  let constants ← match input.prepare with
+    | .ok constants => pure constants
+    | .error error => return .error error
+  compileDecoratedConsts constants rustRef numWorkers dbg resourceProfile
+
+/-- Compile an isolated source list, extracting its checked occurrence records. -/
+def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
+    (rustRef : Option (Std.HashMap Name Address) := none)
+    (numWorkers : Nat := 32) (dbg : Bool := false)
+    (resourceProfile : Option Ix.Resource.Profile := none) :
+    IO (Except String LeanPipelineOut) := do
+  let input ← match Ix.Compile.CompileInput.fromAnnotations consts with
+    | .ok input => pure input
+    | .error error => return .error (toString error)
+  compileLeanInput input rustRef numWorkers dbg resourceProfile
+
+/-- Native compiler entrypoint with an explicitly committed resource profile. -/
+@[extern "rs_compile_env_to_ixon_profile"]
+opaque rsCompileEnvProfileFFI :
+  @& List (Lean.Name × Lean.ConstantInfo) → @& ByteArray → IO Ixon.RawEnv
+
+def rsCompileInput (input : Ix.Compile.CompileInput)
+    (resourceProfile : Option Ix.Resource.Profile := none) : IO Ixon.Env := do
+  let constants ← IO.ofExcept input.prepare
+  let raw ← match resourceProfile with
+    | none => rsCompileEnvFFI constants
+    | some profile =>
+      let _ ← IO.ofExcept profile.address
+      rsCompileEnvProfileFFI constants profile.bytes
+  return raw.toEnv
+
 end Ix.CompileM
+
+
+
diff --git a/Ix/CompileM.lean b/Ix/CompileM.lean
index d3a4d8c8f..2ac918071 100644
--- a/Ix/CompileM.lean
+++ b/Ix/CompileM.lean
@@ -16,6 +16,8 @@ import Std.Sync
 public import Ix.Ixon
 public import Ix.IxonUniv
 public import Ix.Environment
+public import Ix.SemanticContract
+public import Ix.Compile.SourceContract.Transport
 public import Ix.Sharing
 public import Ix.Common
 public import Ix.Store
@@ -816,7 +818,7 @@ def compileExprNoSurgeryStep
       let (v, valRoot) ← compile val
       let (b, bodyRoot) ← compile body
       let root ← allocArenaNode (.letBinder nameAddr tyRoot valRoot bodyRoot)
-      pure (.letE nonDep t v b, root)
+      pure (.leanLet nonDep t v b, root)
 
     | .lit (.natVal n) _ => do
       let bytes := ByteArray.mk (Nat.toBytesLE n)
@@ -846,6 +848,14 @@ def compileExprNoSurgeryStep
       pure (.prj typeRefIdx fieldIdx.toUInt64 s, root)
 
     | .mdata kvData inner _ => do
+      if SemanticContract.hasMetadata kvData then
+        let contract ← match SemanticContract.read kvData with
+          | .ok contract => pure contract
+          | .error error => throw (.unsupportedExpr error)
+        let (value, root) ← compile inner
+        match contract.lower inner value with
+        | .ok value => return (value, root)
+        | .error error => throw (.unsupportedExpr error)
       let kvmap ← compileKVMap kvData
       let (innerResult, innerRoot) ← compile inner
       let root ← allocArenaNode (.mdata #[kvmap] innerRoot)
@@ -931,6 +941,9 @@ def auditPlanHeadArities (owner : Name) (top : Expr) : CompileM Unit := do
   if cenv.callSitePlans.isEmpty && cenv.belowCallSitePlans.isEmpty &&
       cenv.brecOnCallSitePlans.isEmpty then
     return
+  let annotated ← match Ix.SemanticContract.inspect top with
+    | .ok annotated => pure annotated
+    | .error error => throw (.unsupportedExpr error)
   -- Lean expressions are DAGs. Large tactic proofs may reach one shared
   -- subexpression through exponentially many tree paths, while the ordinary
   -- compiler memoizes it. Keep the audit linear in unique nodes as well.
@@ -949,6 +962,8 @@ def auditPlanHeadArities (owner : Name) (top : Expr) : CompileM Unit := do
       match head with
       | .const name _ _ =>
         if let some arity := planHeadArity? cenv name then
+          if annotated then
+            throw (.unsupportedExpr s!"resource contracts across non-identity call-site surgery: {owner.pretty} calls {name.pretty}")
           let need := if arity.headRewrite then arity.expected else arity.floor
           if args.size < need && (obscured || arity.headRewrite) then
             let suffix := if obscured then
@@ -962,6 +977,8 @@ expected at least {need}{suffix}")
         stack := stack.push (arg, false)
     | .const name _ _ =>
       if let some arity := planHeadArity? cenv name then
+        if annotated then
+          throw (.unsupportedExpr s!"resource contracts across non-identity call-site surgery: {owner.pretty} calls {name.pretty}")
         if obscured || arity.headRewrite then
           let need := if arity.headRewrite then arity.expected else arity.floor
           let suffix := if obscured then
@@ -1191,7 +1208,7 @@ partial def compileExprSurgical (e : Expr) : CompileM (Ixon.Expr × UInt64) := d
     let (v, valRoot) ← compileExprSurgical val
     let (b, bodyRoot) ← compileExprSurgical body
     let root ← allocArenaNode (.letBinder nameAddr tyRoot valRoot bodyRoot)
-    pure (.letE nonDep t v b, root)
+    pure (.leanLet nonDep t v b, root)
 
   | .lit (.natVal n) _ => do
     let bytes := ByteArray.mk (Nat.toBytesLE n)
@@ -1219,6 +1236,14 @@ partial def compileExprSurgical (e : Expr) : CompileM (Ixon.Expr × UInt64) := d
     pure (.prj typeRefIdx fieldIdx.toUInt64 s, root)
 
   | .mdata kvData inner _ => do
+    if SemanticContract.hasMetadata kvData then
+      let contract ← match SemanticContract.read kvData with
+        | .ok contract => pure contract
+        | .error error => throw (.unsupportedExpr error)
+      let (value, root) ← compileExprSurgical inner
+      match contract.lower inner value with
+      | .ok value => return (value, root)
+      | .error error => throw (.unsupportedExpr error)
     let kvmap ← compileKVMap kvData
     let (innerResult, innerRoot) ← compileExprSurgical inner
     let root ← allocArenaNode (.mdata #[kvmap] innerRoot)
@@ -2040,9 +2065,24 @@ well-founded measure. -/
   | _, .mvar .. => throw (.unsupportedExpr "metavariable in comparison")
   | .fvar .., _ => throw (.unsupportedExpr "fvar in comparison")
   | _, .fvar .. => throw (.unsupportedExpr "fvar in comparison")
-  | .mdata _ x _, .mdata _ y _ => compareExpr ctx xlvls ylvls x y
-  | .mdata _ x _, y => compareExpr ctx xlvls ylvls x y
-  | x, .mdata _ y _ => compareExpr ctx xlvls ylvls x y
+  | .mdata dx xi hx, .mdata dy yi hy => do
+    if SemanticContract.hasMetadata dx then
+      if SemanticContract.hasMetadata dy then
+        let cx ← match SemanticContract.read dx with
+          | .ok c => pure c | .error e => throw (.unsupportedExpr e)
+        let cy ← match SemanticContract.read dy with
+          | .ok c => pure c | .error e => throw (.unsupportedExpr e)
+        let order := compare cx.orderKey cy.orderKey
+        if order != .eq then return ⟨true, order⟩
+        compareExpr ctx xlvls ylvls xi yi
+      else compareExpr ctx xlvls ylvls (.mdata dx xi hx) yi
+    else compareExpr ctx xlvls ylvls xi (.mdata dy yi hy)
+  | .mdata data x _, y =>
+    if SemanticContract.hasMetadata data then pure ⟨true, .gt⟩
+    else compareExpr ctx xlvls ylvls x y
+  | x, .mdata data y _ =>
+    if SemanticContract.hasMetadata data then pure ⟨true, .lt⟩
+    else compareExpr ctx xlvls ylvls x y
   | .bvar x _, .bvar y _ => pure ⟨true, compare x y⟩
   | .bvar .., _ => pure ⟨true, .lt⟩
   | _, .bvar .. => pure ⟨true, .gt⟩
@@ -3986,7 +4026,7 @@ opaque rsCompileValidateAuxFFI
     `allowPartial := true`. Returns the structured compile status. -/
 def rsCompileEnvBytes (leanEnv : Lean.Environment) (outPath : String)
     (allowPartial : Bool := false) : IO CompileEnvStatus := do
-  let constList := leanEnv.constants.toList
+  let constList ← IO.ofExcept <| Ix.Compile.prepareRegisteredConstants leanEnv leanEnv.constants.toList
   let status ← rsCompileEnvBytesFFI constList outPath allowPartial
   if !allowPartial && !status.ungrounded.isEmpty then
     throw <| IO.userError <|
@@ -4043,6 +4083,7 @@ opaque rsCompilePhasesFFI : @& List (Lean.Name × Lean.ConstantInfo) → IO Rust
     `rsCompilePhases` covers the whole-environment case. -/
 def rsCompilePhasesOf (constList : List (Lean.Name × Lean.ConstantInfo)) :
     IO CompilePhases := do
+  let constList ← IO.ofExcept <| Ix.Compile.prepareSourceConstants constList
   let raw ← rsCompilePhasesFFI constList
 
   -- Convert RawEnvironment to Environment
@@ -4058,21 +4099,30 @@ def rsCompilePhasesOf (constList : List (Lean.Name × Lean.ConstantInfo)) :
 
 /-- Run all compilation phases using Rust and convert to Lean-friendly types.
     This is the main entry point for getting Rust compilation results. -/
-def rsCompilePhases (leanEnv : Lean.Environment) : IO CompilePhases :=
-  rsCompilePhasesOf leanEnv.constants.toList
+def rsCompilePhases (leanEnv : Lean.Environment) : IO CompilePhases := do
+  let constants ← IO.ofExcept <| Ix.Compile.prepareRegisteredConstants leanEnv leanEnv.constants.toList
+  let raw ← rsCompilePhasesFFI constants
+  return { rawEnv := raw.rawEnv.toEnvironment
+           condensed := raw.condensed.toCondensedBlocks
+           compileEnv := raw.compileEnv.toEnv }
 
 /-- Compile an explicit constant list to Ixon.Env using the Rust
     compiler. Use for compiles over constructed environments (e.g. the
     catalog `--audit` per-library comparison). -/
 def rsCompileEnvOf (constList : List (Lean.Name × Lean.ConstantInfo)) :
     IO Ixon.Env := do
+  let constList ← IO.ofExcept <| Ix.Compile.prepareSourceConstants constList
   let rawEnv ← rsCompileEnvFFI constList
   pure rawEnv.toEnv
 
 /-- Compile a Lean environment to Ixon.Env using the Rust compiler.
     Uses the direct FFI that returns structured Lean objects. -/
-def rsCompileEnv (leanEnv : Lean.Environment) : IO Ixon.Env :=
-  rsCompileEnvOf leanEnv.constants.toList
+def rsCompileEnv (leanEnv : Lean.Environment) : IO Ixon.Env := do
+  let constants ← IO.ofExcept <| Ix.Compile.prepareRegisteredConstants leanEnv leanEnv.constants.toList
+  let raw ← rsCompileEnvFFI constants
+  return raw.toEnv
 
 end
 end Ix.CompileM
+
+
diff --git a/Ix/DecompileM.lean b/Ix/DecompileM.lean
index b380e9017..910c57500 100644
--- a/Ix/DecompileM.lean
+++ b/Ix/DecompileM.lean
@@ -12,6 +12,7 @@ module
 -/
 
 public import Ix.Ixon
+public import Ix.SemanticContract
 public import Ix.Address
 public import Ix.Environment
 public import Ix.Common
@@ -99,7 +100,7 @@ structure BlockCtx where
 
 /-- Per-block mutable state (caches). -/
 structure BlockState where
-  exprCache : Std.HashMap (UInt64 × UInt64) Ix.Expr := {}
+  exprCache : Std.HashMap (Ixon.Expr × UInt64) Ix.Expr := {}
   univCache : Std.HashMap UInt64 Ix.Level := {}
   deriving Inhabited
 
@@ -394,7 +395,7 @@ partial def decompileExpr (e : Ixon.Expr) (arenaIdx : UInt64) : DecompileM Ix.Ex
   | _ =>
 
   -- Check cache
-  let cacheKey := (hash e, arenaIdx)
+  let cacheKey := (e, arenaIdx)
   if let some cached := (← get).exprCache.get? cacheKey then return cached
 
   -- 2. Follow mdata chain
@@ -405,12 +406,27 @@ partial def decompileExpr (e : Ixon.Expr) (arenaIdx : UInt64) : DecompileM Ix.Ex
     match ← getArenaNode currentIdx with
     | .mdata kvmaps child =>
       for kvm in kvmaps do
-        mdataLayers := mdataLayers.push (← decompileKVMap kvm)
+        let data ← decompileKVMap kvm
+        if Ix.SemanticContract.hasMetadata data then
+          throw (.badConstantFormat "semantic contracts cannot come from optional metadata")
+        mdataLayers := mdataLayers.push data
       currentIdx := child
     | _ => done := true
 
   let node ← getArenaNode currentIdx
 
+  match node with
+  | .callSite .. | .etaCallSite .. =>
+    let ctx ← getCtx
+    let annotated ← match Ix.SemanticContract.containsIxon ctx.sharing e with
+      | .ok annotated => pure annotated
+      | .error error => throw (.badConstantFormat error)
+    if annotated then
+      throw (.badConstantFormat "optional call-site replay would rewrite a semantic contract")
+  | _ => pure ()
+  if let some contract := Ix.SemanticContract.ofIxon? e then
+    mdataLayers := mdataLayers.push contract.ixMetadata
+
   -- 3. Match (arenaNode, ixonExpr) → Ix.Expr
   let result ← match node, e with
   -- Eta adapter replay: strip the synthesized lambda telescope, read the
@@ -625,13 +641,13 @@ but canonical telescope has only {canonicalArgs.size} args")
     let tyExpr ← decompileExpr ty tyChild
     let valExpr ← decompileExpr val valChild
     let bodyExpr ← decompileExpr body bodyChild
-    pure (applyMdata (Ix.Expr.mkLetE letName tyExpr valExpr bodyExpr nonDep) mdataLayers)
+    pure (applyMdata (Ix.Expr.mkLetE letName tyExpr valExpr bodyExpr nonDep.nonDep) mdataLayers)
 
   | _, .letE nonDep ty val body => do
     let tyExpr ← decompileExpr ty UInt64.MAX
     let valExpr ← decompileExpr val UInt64.MAX
     let bodyExpr ← decompileExpr body UInt64.MAX
-    pure (applyMdata (Ix.Expr.mkLetE Ix.Name.mkAnon tyExpr valExpr bodyExpr nonDep) mdataLayers)
+    pure (applyMdata (Ix.Expr.mkLetE Ix.Name.mkAnon tyExpr valExpr bodyExpr nonDep.nonDep) mdataLayers)
 
   -- Prj with arena metadata
   | .prj structNameAddr child, .prj _typeRefIdx fieldIdx val => do
@@ -1009,3 +1025,4 @@ def decompileAllParallelIO (ixonEnv : Ixon.Env)
 end Ix.DecompileM
 
 end
+
diff --git a/Ix/IxVM/ClaimHarness.lean b/Ix/IxVM/ClaimHarness.lean
index 45446a614..559e206ae 100644
--- a/Ix/IxVM/ClaimHarness.lean
+++ b/Ix/IxVM/ClaimHarness.lean
@@ -219,7 +219,7 @@ private def hintToG : Lean.ReducibilityHints → Aiur.G
 /-! ## IxVM IOBuffer interface
 
 This section is the normative description of the host↔kernel interface.
-The host seeds payloads on five channels (0–4); the Aiur kernel consumes
+The host seeds payloads on channels 0–5; the Aiur kernel consumes
 them via `io_get_info` + `#read_byte_stream`. Each channel carries one
 value shape and each key is the content address of the value it maps to
 — no overloading, no in-band discriminators.
@@ -231,6 +231,12 @@ value shape and each key is the content address of the value it maps to
 | 2       | constant wire bytes    | const addr            | const bytes  |
 | 3       | Defn reducibility hint | Defn addr             | single G     |
 | 4       | blob raw bytes         | blob addr             | raw bytes    |
+| 5       | resource profile       | profile addr          | profile bytes |
+
+Channel 5 reserves the native resource-claim witness layout. IxVM currently
+rejects `resource-v1` claims explicitly: a native validation result cannot be
+used as a circuit proof. Its `Check` and `CheckEnv` claims assert erased Lean
+typing and bind that validator identity in their hashed claim bytes.
 
 An address is seeded on ch 2 iff it is a constant, and on ch 4 iff it is
 a blob. The two sets are disjoint and neither carries an entry on the
@@ -364,7 +370,8 @@ def closureFrom (env : Ixon.Env) (target : Address) : Std.HashSet Address :=
     address the claim variant names (plus any caller-supplied
     `AssumptionTree`s under their merkle roots). -/
 def buildClaimWitness (env : Ixon.Env) (claim : Ix.Claim)
-    (trees : Std.HashMap Address Ix.AssumptionTree := {}) :
+    (trees : Std.HashMap Address Ix.AssumptionTree := {})
+    (profiles : Std.HashMap Address ByteArray := {}) :
     Except String ClaimWitness := do
   let claimBytes := Ix.Claim.ser claim
   let digestKey := packedDigestKey (Address.blake3 claimBytes)
@@ -387,6 +394,13 @@ def buildClaimWitness (env : Ixon.Env) (claim : Ix.Claim)
     ioBuffer := addEntries env (fun _ => true) ioBuffer
     ioBuffer ← seedTreeAt root trees ioBuffer
     ioBuffer ← seedAsm asm ioBuffer
+  | .resource root profile =>
+    ioBuffer := addEntries env (fun _ => true) ioBuffer
+    ioBuffer ← seedTreeAt root trees ioBuffer
+    let some bytes := profiles[profile]? <|> env.blobs[profile]?
+      | throw s!"no resource profile supplied for {profile}"
+    unless Address.blake3 bytes == profile do throw "resource profile hash mismatch"
+    ioBuffer := ioBuffer.extend 5 (addrKey profile) (bytes.data.map .ofUInt8)
   | .reveal comm _info =>
     ioBuffer := addEntries env (closureFrom env comm).contains ioBuffer
   | .contains tree _target =>
diff --git a/Ix/IxVM/Convert.lean b/Ix/IxVM/Convert.lean
index 3c3485a62..9f20187f5 100644
--- a/Ix/IxVM/Convert.lean
+++ b/Ix/IxVM/Convert.lean
@@ -5,6 +5,9 @@ public section
 
 namespace IxVM
 
+/-- Erased Lean typing only. Contracts remain committed in the source bytes;
+`Check` and `CheckEnv` bind validator `erased-lean-v1`. Resource validity
+requires the separate native `resource-v1` validator. -/
 def convert := ⟦
   -- ============================================================================
   -- Convert — addr-first Ixon → KExpr / KConstantInfo
@@ -185,6 +188,8 @@ def convert := ⟦
           convert_expr(ty, sharing, refs, recur_addrs, univs),
           convert_expr(body, sharing, refs, recur_addrs, univs))),
 
+      -- A shared borrow has the same erased value as an ordinary let.
+      -- This conversion proves no ownership, usage, or escape property.
       Expr.Let(_, ty, val, body) =>
         store(KExprNode.Let(
           convert_expr(ty, sharing, refs, recur_addrs, univs),
diff --git a/Ix/IxVM/Ixon.lean b/Ix/IxVM/Ixon.lean
index ad255b9f0..744784aad 100644
--- a/Ix/IxVM/Ixon.lean
+++ b/Ix/IxVM/Ixon.lean
@@ -6,7 +6,7 @@ public section
 namespace IxVM
 
 def ixon := ⟦
-  -- Ixon v2 binder usage. The wire representation is the enum ordinal.
+  -- Ixon v3 keeps usage, ownership, and locality independent.
   enum Uses {
     Erased,
     Linear,
@@ -14,13 +14,17 @@ def ixon := ⟦
     Many
   }
 
-  -- Ixon v2 forall-result ownership. The wire representation is the enum
-  -- ordinal in bit 2 of the forall mode byte.
   enum Owned {
     Unique,
     Shared
   }
 
+  enum Locality { Unrestricted, Local }
+  enum ValueContract { Mk(Owned, Locality) }
+  enum BinderContract { Mk(Uses, ValueContract) }
+  enum LetKind { Value, BorrowShared }
+  enum LetContract { Mk(G, LetKind, BinderContract) }
+
   -- Expression type
   enum Expr {
     Srt(U64),
@@ -31,9 +35,9 @@ def ixon := ⟦
     Str(U64),
     Nat(U64),
     App(&Expr, &Expr),
-    Lam(Uses, &Expr, &Expr),
-    All(Uses, Owned, &Expr, &Expr),
-    Let(U64, &Expr, &Expr, &Expr),
+    Lam(BinderContract, &Expr, &Expr),
+    All(BinderContract, ValueContract, &Expr, &Expr),
+    Let(LetContract, &Expr, &Expr, &Expr),
     Share(U64)
   }
 
diff --git a/Ix/IxVM/IxonDeserialize.lean b/Ix/IxVM/IxonDeserialize.lean
index 6e01e306b..6956d2375 100644
--- a/Ix/IxVM/IxonDeserialize.lean
+++ b/Ix/IxVM/IxonDeserialize.lean
@@ -10,19 +10,10 @@ def ixonDeserialize := ⟦
   -- Byte reading primitives
   -- ============================================================================
 
-  -- NOTE: hot readers (`get_u64_le`, the tag parsers, `get_address`) inline
-  -- the uncons as `let ListNode.Cons(byte, s) = load(stream)` instead of
-  -- calling this: a `load` is a memory-table lookup already paid by
-  -- `read_byte` itself, so inlining deletes one full dispatch row per byte
-  -- read. The behavioral difference is only on truncated input: `read_byte`
-  -- zero-pads at Nil, the inline uncons fails the prover (well-formed Ixon
-  -- never over-reads). Cold once-per-constant parsers keep the call for the
-  -- padding semantics and narrower circuits.
+  -- Every reader rejects truncation, including cold declaration fields.
   fn read_byte(stream: ByteStream) -> (U8, ByteStream) {
-    match load(stream) {
-      ListNode.Cons(byte, rest) => (byte, rest),
-      ListNode.Nil => (0u8, store(ListNode.Nil)),
-    }
+    let ListNode.Cons(byte, rest) = load(stream);
+    (byte, rest)
   }
 
   -- Read num_bytes little-endian bytes into a u64
@@ -61,7 +52,13 @@ def ixonDeserialize := ⟦
         -- matches the format.
         assert_eq!(u8_less_than(u8_from_field_unsafe(num_bytes), 9u8), 1,
           "tag0: payload width exceeds 8 bytes");
-        get_u64_le(s, num_bytes),
+        let (size, s2) = get_u64_le(s, num_bytes);
+        assert_eq!(to_field(u64_byte_count(size)), num_bytes, "nonminimal tag0 width");
+        match num_bytes {
+          1 => assert_eq!(u8_less_than(size[0], 128u8), 0, "nonminimal tag0 value"); (); (),
+          _ => (),
+        };
+        (size, s2),
     }
   }
 
@@ -82,6 +79,11 @@ def ixonDeserialize := ⟦
         assert_eq!(u8_less_than(u8_from_field_unsafe(num_bytes), 9u8), 1,
           "tag2: payload width exceeds 8 bytes");
         let (size, s2) = get_u64_le(s, num_bytes);
+        assert_eq!(to_field(u64_byte_count(size)), num_bytes, "nonminimal tag2 width");
+        match num_bytes {
+          1 => assert_eq!(u8_less_than(size[0], 32u8), 0, "nonminimal tag2 value"); (); (),
+          _ => (),
+        };
         ((flag, size), s2),
     }
   }
@@ -99,6 +101,11 @@ def ixonDeserialize := ⟦
       _ =>
         let num_bytes = small_size + 1;
         let (size, s2) = get_u64_le(s, num_bytes);
+        assert_eq!(to_field(u64_byte_count(size)), num_bytes, "nonminimal tag4 width");
+        match num_bytes {
+          1 => assert_eq!(u8_less_than(size[0], 8u8), 0, "nonminimal tag4 value"); (); (),
+          _ => (),
+        };
         ((flag, size), s2),
     }
   }
@@ -122,6 +129,10 @@ def ixonDeserialize := ⟦
   -- Expression deserialization
   -- ============================================================================
 
+  -- Counted parsers consume each element through strict readers before
+  -- recurring. Truncation therefore rejects during parsing, without a
+  -- preliminary traversal of the byte stream.
+
   -- App telescope: read count args, wrapping func in App nodes. `func` is passed
   -- by pointer (loaded only at the base case) so the recursion doesn't carry the
   -- wide `Expr` union by value on every row.
@@ -135,37 +146,35 @@ def ixonDeserialize := ⟦
     }
   }
 
-  -- Ixon v2 encodes one usage byte before each lambda binder type.
-  fn get_lam_mode(stream: ByteStream) -> (Uses, ByteStream) {
-    let ListNode.Cons(mode, s) = load(stream);
-    assert_eq!(u8_less_than(mode, 4u8), 1, "invalid lambda mode");
-    match mode {
-      0 => (Uses.Erased, s),
-      1 => (Uses.Linear, s),
-      2 => (Uses.Affine, s),
-      3 => (Uses.Many, s),
-    }
+  -- Decode independent usage, ownership, and locality bits.
+  fn value_contract_from_bits(owned_bit: G, locality_bit: G) -> ValueContract {
+    let owned = match owned_bit { 0 => Owned.Unique, 1 => Owned.Shared, };
+    let locality = match locality_bit { 0 => Locality.Unrestricted, 1 => Locality.Local, };
+    ValueContract.Mk(owned, locality)
   }
 
-  -- Ixon v2 forall mode: usage in bits 0-1, result ownership in bit 2.
-  -- Values above 7 carry reserved bits and are rejected by the host codecs.
-  fn get_all_mode(stream: ByteStream) -> ((Uses, Owned), ByteStream) {
-    let ListNode.Cons(mode, s) = load(stream);
-    assert_eq!(u8_less_than(mode, 8u8), 1, "invalid forall mode");
-    match mode {
-      0 => ((Uses.Erased, Owned.Unique), s),
-      1 => ((Uses.Linear, Owned.Unique), s),
-      2 => ((Uses.Affine, Owned.Unique), s),
-      3 => ((Uses.Many, Owned.Unique), s),
-      4 => ((Uses.Erased, Owned.Shared), s),
-      5 => ((Uses.Linear, Owned.Shared), s),
-      6 => ((Uses.Affine, Owned.Shared), s),
-      7 => ((Uses.Many, Owned.Shared), s),
-    }
+  fn binder_contract_from_bits(b0: G, b1: G, b2: G, b3: G) -> BinderContract {
+    let uses = match b0 + 2 * b1 { 0 => Uses.Erased, 1 => Uses.Linear, 2 => Uses.Affine, 3 => Uses.Many, };
+    BinderContract.Mk(uses, value_contract_from_bits(b2, b3))
+  }
+
+  fn get_lam_mode(stream: ByteStream) -> (BinderContract, ByteStream) {
+    let (mode, s) = read_byte(stream);
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = u8_bit_decomposition(mode);
+    assert_eq!(b4 + b5 + b6 + b7, 0, "reserved binder contract bits");
+    (binder_contract_from_bits(b0, b1, b2, b3), s)
+  }
+
+  -- Decode the complete input and result contracts.
+  fn get_all_mode(stream: ByteStream) -> ((BinderContract, ValueContract), ByteStream) {
+    let (mode, s) = read_byte(stream);
+    let [b0, b1, b2, b3, b4, b5, b6, b7] = u8_bit_decomposition(mode);
+    assert_eq!(b6 + b7, 0, "reserved forall contract bits");
+    ((binder_contract_from_bits(b0, b1, b2, b3), value_contract_from_bits(b4, b5)), s)
   }
 
-  -- Lam telescope: read count (mode, type) binders then body, wrap as nested
-  -- Lams. The base may not itself be a Lam: the v2 encoding requires maximal
+  -- Lam telescope: read count (contract, type) binders then body, wrap as nested
+  -- Lams. The base may not itself be a Lam: the v3 encoding requires maximal
   -- telescope compression.
   fn get_lam_telescope(stream: ByteStream, count: U64) -> (&Expr, ByteStream) {
     let is_zero = u64_is_zero(count);
@@ -179,15 +188,15 @@ def ixonDeserialize := ⟦
           _ => (body, s),
         },
       0 =>
-        let (uses, s) = get_lam_mode(stream);
+        let (contract, s) = get_lam_mode(stream);
         let (ty, s2) = get_expr(s);
         let (inner, s3) = get_lam_telescope(s2, relaxed_u64_pred(count));
-        (store(Expr.Lam(uses, ty, inner)), s3),
+        (store(Expr.Lam(contract, ty, inner)), s3),
     }
   }
 
-  -- All telescope: read count (mode, type) binders then body, wrap as nested
-  -- Alls, again requiring maximal telescope compression.
+  -- All telescope: read count (input/result contracts, type) binders then body,
+  -- wrap as nested Alls, again requiring maximal telescope compression.
   fn get_all_telescope(stream: ByteStream, count: U64) -> (&Expr, ByteStream) {
     let is_zero = u64_is_zero(count);
     match is_zero {
@@ -201,10 +210,10 @@ def ixonDeserialize := ⟦
         },
       0 =>
         let (mode, s) = get_all_mode(stream);
-        let (uses, owned) = mode;
+        let (input, result) = mode;
         let (ty, s2) = get_expr(s);
         let (inner, s3) = get_all_telescope(s2, relaxed_u64_pred(count));
-        (store(Expr.All(uses, owned, ty, inner)), s3),
+        (store(Expr.All(input, result, ty, inner)), s3),
     }
   }
 
@@ -268,17 +277,17 @@ def ixonDeserialize := ⟦
           _ => get_app_telescope(func, s2, size),
         },
 
-      -- Lam: Tag4(0x8, count) + (uses, type)... + body
+      -- Lam: Tag4(0x8, count) + (contract, type)... + body
       0x8 =>
         assert_eq!(u64_is_zero(size), 0, "Lam with zero binders");
         get_lam_telescope(s, size),
 
-      -- All: Tag4(0x9, count) + (uses|owned<<2, type)... + body
+      -- All: Tag4(0x9, count) + (input|result<<4, type)... + body
       0x9 =>
         assert_eq!(u64_is_zero(size), 0, "All with zero binders");
         get_all_telescope(s, size),
 
-      -- Let: Tag4(0xA, non_dep) + expr(ty) + expr(val) + expr(body)
+      -- Let: Tag4(0xA, flags) + binder + expr(ty) + expr(val) + expr(body)
       0xA => get_expr_let(s, size),
 
       -- Share: Tag4(0xB, idx)
@@ -289,13 +298,17 @@ def ixonDeserialize := ⟦
   -- Let arm of get_expr, split out: three recursive `get_expr` calls make it the
   -- widest (and a rare) arm, so inlined it taxes every get_expr row.
   fn get_expr_let(s: ByteStream, size: U64) -> (&Expr, ByteStream) {
-    let is_dep = u64_eq(size, [0u8; 8]);
-    let is_non_dep = u64_eq(size, [1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]);
-    assert_eq!(is_dep + is_non_dep, 1, "invalid let nonDep flag");
-    let (ty, s2) = get_expr(s);
-    let (val, s3) = get_expr(s2);
-    let (body, s4) = get_expr(s3);
-    (store(Expr.Let(size, ty, val, body)), s4)
+    let [head, b1, b2, b3, b4, b5, b6, b7] = size;
+    assert_eq!(to_field(b1) + to_field(b2) + to_field(b3) + to_field(b4) +
+      to_field(b5) + to_field(b6) + to_field(b7), 0, "oversized let flags");
+    assert_eq!(u8_less_than(head, 4u8), 1, "reserved let flags");
+    let bits = u8_bit_decomposition(head);
+    let kind = match bits[1] { 0 => LetKind.Value, 1 => LetKind.BorrowShared, };
+    let (contract, s1) = get_lam_mode(s);
+    let (ty, s2) = get_expr(s1);
+    let (value, s3) = get_expr(s2);
+    let (body, rest) = get_expr(s3);
+    (store(Expr.Let(LetContract.Mk(bits[0], kind, contract), ty, value, body)), rest)
   }
 
 
@@ -505,6 +518,7 @@ def ixonDeserialize := ⟦
   --           Tag0(motives) + Tag0(minors) + expr(typ) + Tag0(rules_len) + rules...
   fn get_recursor(stream: ByteStream) -> (Recursor, ByteStream) {
     let (bools_byte, s) = read_byte(stream);
+    assert_eq!(u8_less_than(bools_byte, 4u8), 1, "invalid recursor flags");
     let bits = u8_bit_decomposition(bools_byte);
     let k = bits[0];
     let is_unsafe = bits[1];
@@ -589,6 +603,7 @@ def ixonDeserialize := ⟦
   --            expr(typ) + Tag0(ctors_len) + ctors...
   fn get_inductive(stream: ByteStream) -> (Inductive, ByteStream) {
     let (bools_byte, s) = read_byte(stream);
+    assert_wire_bool(bools_byte);
     let bits = u8_bit_decomposition(bools_byte);
     let is_unsafe = bits[0];
     let (lvls, s2) = get_tag0(s);
diff --git a/Ix/IxVM/IxonSerialize.lean b/Ix/IxVM/IxonSerialize.lean
index 44097f499..85c183e56 100644
--- a/Ix/IxVM/IxonSerialize.lean
+++ b/Ix/IxVM/IxonSerialize.lean
@@ -49,10 +49,12 @@ def ixonSerialize := ⟦
         let count = all_telescope_count(expr);
         put_tag4(0x9, count, put_all_telescope(expr, rest)),
 
-      -- Let: Tag4(0xA, non_dep) + put_expr(ty) + put_expr(val) + put_expr(body)
-      -- non_dep: 0 for dependent, 1 for non-dependent
-      Expr.Let(non_dep, &ty, &val, &body) =>
-        put_tag4(0xA, non_dep, put_expr(ty, put_expr(val, put_expr(body, rest)))),
+      -- Let: flags in Tag4 size, then the binder byte and three children.
+      Expr.Let(LetContract.Mk(non_dep, kind, contract), &ty, &val, &body) =>
+        let kind_bit = match kind { LetKind.Value => 0, LetKind.BorrowShared => 1, };
+        let flags = [u8_from_field_unsafe(non_dep + 2 * kind_bit), 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8];
+        put_tag4(0xA, flags, put_lam_mode(contract,
+          put_expr(ty, put_expr(val, put_expr(body, rest))))),
 
       -- Share: Tag4(0xB, idx)
       Expr.Share(idx) => put_tag4(0xB, idx, rest),
@@ -119,28 +121,29 @@ def ixonSerialize := ⟦
     }
   }
 
-  -- Write an Ixon v2 lambda usage byte.
-  fn put_lam_mode(uses: Uses, rest: ByteStream) -> ByteStream {
-    match uses {
-      Uses.Erased => store(ListNode.Cons(0u8, rest)),
-      Uses.Linear => store(ListNode.Cons(1u8, rest)),
-      Uses.Affine => store(ListNode.Cons(2u8, rest)),
-      Uses.Many => store(ListNode.Cons(3u8, rest)),
-    }
+  -- Two-bit value contract: ownership and locality.
+  fn value_contract_code(value: ValueContract) -> G {
+    let ValueContract.Mk(owned, locality) = value;
+    let o = match owned { Owned.Unique => 0, Owned.Shared => 1, };
+    let l = match locality { Locality.Unrestricted => 0, Locality.Local => 1, };
+    o + 2 * l
   }
 
-  -- Write usage in bits 0-1 and forall-result ownership in bit 2.
-  fn put_all_mode(uses: Uses, owned: Owned, rest: ByteStream) -> ByteStream {
-    match (uses, owned) {
-      (Uses.Erased, Owned.Unique) => store(ListNode.Cons(0u8, rest)),
-      (Uses.Linear, Owned.Unique) => store(ListNode.Cons(1u8, rest)),
-      (Uses.Affine, Owned.Unique) => store(ListNode.Cons(2u8, rest)),
-      (Uses.Many, Owned.Unique) => store(ListNode.Cons(3u8, rest)),
-      (Uses.Erased, Owned.Shared) => store(ListNode.Cons(4u8, rest)),
-      (Uses.Linear, Owned.Shared) => store(ListNode.Cons(5u8, rest)),
-      (Uses.Affine, Owned.Shared) => store(ListNode.Cons(6u8, rest)),
-      (Uses.Many, Owned.Shared) => store(ListNode.Cons(7u8, rest)),
-    }
+  -- Four-bit binder contract: usage and value contract.
+  fn binder_contract_code(contract: BinderContract) -> G {
+    let BinderContract.Mk(uses, value) = contract;
+    let u = match uses { Uses.Erased => 0, Uses.Linear => 1, Uses.Affine => 2, Uses.Many => 3, };
+    u + 4 * value_contract_code(value)
+  }
+
+  fn put_lam_mode(contract: BinderContract, rest: ByteStream) -> ByteStream {
+    store(ListNode.Cons(u8_from_field_unsafe(binder_contract_code(contract)), rest))
+  }
+
+  -- Four input bits and two result bits.
+  fn put_all_mode(contract: BinderContract, result: ValueContract, rest: ByteStream) -> ByteStream {
+    let code = binder_contract_code(contract) + 16 * value_contract_code(result);
+    store(ListNode.Cons(u8_from_field_unsafe(code), rest))
   }
 
   -- Count nested App expressions
@@ -176,20 +179,20 @@ def ixonSerialize := ⟦
     }
   }
 
-  -- Serialize Lam telescope body (mode/type pairs, then body)
+  -- Serialize Lam telescope body (contract/type pairs, then body)
   fn put_lam_telescope(expr: Expr, rest: ByteStream) -> ByteStream {
     match expr {
-      Expr.Lam(uses, &ty, &body) =>
-        put_lam_mode(uses, put_expr(ty, put_lam_telescope(body, rest))),
+      Expr.Lam(contract, &ty, &body) =>
+        put_lam_mode(contract, put_expr(ty, put_lam_telescope(body, rest))),
       _ => put_expr(expr, rest),
     }
   }
 
-  -- Serialize All telescope body (mode/type pairs, then body)
+  -- Serialize All telescope body (input/result contracts and types, then body)
   fn put_all_telescope(expr: Expr, rest: ByteStream) -> ByteStream {
     match expr {
-      Expr.All(uses, owned, &ty, &body) =>
-        put_all_mode(uses, owned, put_expr(ty, put_all_telescope(body, rest))),
+      Expr.All(input, result, &ty, &body) =>
+        put_all_mode(input, result, put_expr(ty, put_all_telescope(body, rest))),
       _ => put_expr(expr, rest),
     }
   }
diff --git a/Ix/IxVM/Kernel/Check.lean b/Ix/IxVM/Kernel/Check.lean
index 543657f44..280aad7fc 100644
--- a/Ix/IxVM/Kernel/Check.lean
+++ b/Ix/IxVM/Kernel/Check.lean
@@ -160,38 +160,38 @@ def check := ⟦
   --  handles Axiom / Defn / Thm / Opaque / Quot. Ind/Ctor/Rec
   -- deferred to .
   fn quot_type_addr() -> Addr {
-    store([0xe7u8, 0x75u8, 0xaau8, 0x31u8, 0x75u8, 0x9au8, 0x9du8, 0x4au8,
-     0xcdu8, 0xbcu8, 0x2bu8, 0x85u8, 0x19u8, 0xffu8, 0x73u8, 0xf5u8,
-     0x75u8, 0x52u8, 0xbbu8, 0x0cu8, 0xbau8, 0x4du8, 0xafu8, 0x16u8,
-     0x59u8, 0xbbu8, 0xa0u8, 0x0fu8, 0x6au8, 0x93u8, 0x1bu8, 0x4bu8])
+    store([0x45u8, 0x04u8, 0x0bu8, 0x31u8, 0x26u8, 0x85u8, 0x51u8, 0x69u8,
+     0xdau8, 0xd9u8, 0x19u8, 0xa9u8, 0x70u8, 0xa9u8, 0xc7u8, 0x2cu8,
+     0xeeu8, 0x58u8, 0x75u8, 0x65u8, 0x8au8, 0xedu8, 0xb3u8, 0xbdu8,
+     0x1fu8, 0x89u8, 0xfcu8, 0xdfu8, 0x8cu8, 0x88u8, 0xedu8, 0xfau8])
   }
 
   fn quot_ctor_addr() -> Addr {
-    store([0x0au8, 0x4cu8, 0xc7u8, 0xc9u8, 0x30u8, 0xddu8, 0x67u8, 0x26u8,
-     0xbbu8, 0xd7u8, 0xf1u8, 0xbcu8, 0x3fu8, 0xeau8, 0x68u8, 0x5du8,
-     0xf5u8, 0xf6u8, 0x66u8, 0x54u8, 0x9du8, 0x65u8, 0x1du8, 0x3eu8,
-     0x76u8, 0x6fu8, 0xe5u8, 0x74u8, 0x6eu8, 0xc4u8, 0x59u8, 0xa4u8])
+    store([0x81u8, 0x16u8, 0x00u8, 0xdfu8, 0xa5u8, 0x9fu8, 0x36u8, 0x12u8,
+     0xcbu8, 0x03u8, 0xc0u8, 0xf0u8, 0x47u8, 0x5au8, 0xf1u8, 0x52u8,
+     0x39u8, 0x9du8, 0xefu8, 0xffu8, 0x92u8, 0x26u8, 0xc6u8, 0xe1u8,
+     0x9fu8, 0xd6u8, 0x48u8, 0x04u8, 0x1au8, 0x68u8, 0x99u8, 0xa9u8])
   }
 
   fn quot_lift_addr() -> Addr {
-    store([0x56u8, 0x02u8, 0x76u8, 0xf9u8, 0x5eu8, 0x0du8, 0x93u8, 0xe2u8,
-     0x7bu8, 0x8cu8, 0x05u8, 0x09u8, 0x79u8, 0x95u8, 0xbfu8, 0x82u8,
-     0x87u8, 0x63u8, 0x32u8, 0xc2u8, 0xe7u8, 0xe3u8, 0x10u8, 0x33u8,
-     0xe0u8, 0xa1u8, 0x94u8, 0x81u8, 0x9eu8, 0x4eu8, 0x8du8, 0x30u8])
+    store([0x86u8, 0xb3u8, 0x65u8, 0xe7u8, 0x5bu8, 0xb4u8, 0x23u8, 0x0fu8,
+     0x04u8, 0xc6u8, 0xe4u8, 0xf3u8, 0xa7u8, 0xcau8, 0x69u8, 0x88u8,
+     0xadu8, 0xf5u8, 0x74u8, 0x61u8, 0x6du8, 0x79u8, 0xa3u8, 0xd7u8,
+     0x47u8, 0x7au8, 0xd6u8, 0x5cu8, 0xacu8, 0x10u8, 0x21u8, 0x10u8])
   }
 
   fn quot_ind_addr() -> Addr {
-    store([0x02u8, 0xf3u8, 0x58u8, 0x80u8, 0x8fu8, 0xd4u8, 0x32u8, 0x8du8,
-     0x74u8, 0x85u8, 0x05u8, 0x82u8, 0xd3u8, 0x60u8, 0x8du8, 0x2du8,
-     0x31u8, 0xe4u8, 0x95u8, 0x19u8, 0xb4u8, 0xc6u8, 0xc6u8, 0x6bu8,
-     0x36u8, 0x05u8, 0xfbu8, 0xe6u8, 0xf4u8, 0x2du8, 0x3cu8, 0x5du8])
+    store([0x17u8, 0x45u8, 0x49u8, 0x1cu8, 0x0du8, 0x65u8, 0x1du8, 0xe0u8,
+     0xbeu8, 0xa5u8, 0x89u8, 0xd5u8, 0xffu8, 0xfbu8, 0xc9u8, 0xbcu8,
+     0x4du8, 0x7fu8, 0xbeu8, 0x89u8, 0x7cu8, 0x1du8, 0x80u8, 0x5bu8,
+     0x1fu8, 0x7fu8, 0x59u8, 0xcau8, 0x96u8, 0x96u8, 0xa6u8, 0xefu8])
   }
 
   fn eq_type_addr() -> Addr {
-    store([0xb2u8, 0x0eu8, 0xa1u8, 0x7bu8, 0xa3u8, 0xd9u8, 0x72u8, 0x3fu8,
-     0x0bu8, 0xd0u8, 0x64u8, 0x57u8, 0xd9u8, 0xcfu8, 0x48u8, 0xceu8,
-     0x26u8, 0xcau8, 0x36u8, 0x61u8, 0x9bu8, 0x94u8, 0x69u8, 0x80u8,
-     0x62u8, 0x7du8, 0xe9u8, 0x23u8, 0x87u8, 0x3eu8, 0x95u8, 0x95u8])
+    store([0xc3u8, 0x7du8, 0x62u8, 0x90u8, 0xe0u8, 0x0fu8, 0xb8u8, 0x65u8,
+     0xfbu8, 0x5du8, 0xb7u8, 0xbcu8, 0xe1u8, 0x8fu8, 0xd6u8, 0x9eu8,
+     0x6du8, 0x16u8, 0x74u8, 0xadu8, 0x57u8, 0x37u8, 0x24u8, 0xb8u8,
+     0x54u8, 0x66u8, 0xeau8, 0x9fu8, 0x75u8, 0x78u8, 0xa2u8, 0x07u8])
   }
 
   -- Returns 1 iff `ty` has at least `n` leading Foralls.
@@ -4017,3 +4017,4 @@ def check := ⟦
 end IxVM
 
 end
+
diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean
index d95aa42c2..db719242e 100644
--- a/Ix/IxVM/Kernel/Claim.lean
+++ b/Ix/IxVM/Kernel/Claim.lean
@@ -1223,10 +1223,15 @@ def claim := ⟦
                   + to_field(sz7)), 0,
       "claim: tag4 size exceeds a single byte");
     let variant = size[0];
+    let (format, s) = read_byte(s);
+    assert_eq!(format, 3u8, "claim: unsupported object format");
+    let (validator, s) = read_byte(s);
     match variant {
       4 =>
+        assert_eq!(validator, 1u8, "claim: wrong validator identity");
         let (target, s2) = get_address(s);
-        let (asm, _s3) = get_opt_addr(s2);
+        let (asm, rest) = get_opt_addr(s2);
+        assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes");
         match asm {
           Option.None => run_check_transitive(target),
           Option.Some(r) =>
@@ -1235,17 +1240,29 @@ def claim := ⟦
             env_walk(target, RBTreeMap.Nil, asm_set, 0),
         },
       5 =>
+        assert_eq!(validator, 1u8, "claim: wrong validator identity");
         let (root, s2) = get_address(s);
-        let (asm, _s3) = get_opt_addr(s2);
+        let (asm, rest) = get_opt_addr(s2);
+        assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes");
         run_check_env(root, asm),
       6 =>
+        assert_eq!(validator, 0u8, "claim: wrong validator identity");
         let (comm, s2) = get_address(s);
-        let (info, _s3) = get_reveal_info(s2);
+        let (info, rest) = get_reveal_info(s2);
+        assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes");
         run_reveal(comm, info),
       7 =>
+        assert_eq!(validator, 0u8, "claim: wrong validator identity");
         let (tree, s2) = get_address(s);
-        let (target, _s3) = get_address(s2);
+        let (target, rest) = get_address(s2);
+        assert_eq!(load(rest), ListNode.Nil, "claim: trailing bytes");
         run_contains(tree, target),
+      9 =>
+        assert_eq!(validator, 2u8, "claim: wrong resource validator identity");
+        -- Native resource admission is not a circuit proof. Keep this
+        -- unsupported boundary explicit; no host success flag is trusted.
+        assert_eq!(0, 1, "claim: resource-v1 is not implemented by IxVM");
+        (),
     }
   }
 ⟧
diff --git a/Ix/IxVM/Kernel/Infer.lean b/Ix/IxVM/Kernel/Infer.lean
index 3f7762dc4..7c89c471a 100644
--- a/Ix/IxVM/Kernel/Infer.lean
+++ b/Ix/IxVM/Kernel/Infer.lean
@@ -380,17 +380,17 @@ def infer := ⟦
   -- Ix.IxVM.Kernel.Primitive::nat_addr / str_addr — content-hashes
   -- of the primitive constants' Ixon serializations.
   fn nat_addr() -> Addr {
-    store([0x1du8, 0xffu8, 0xfdu8, 0xe4u8, 0x8cu8, 0x4eu8, 0xf6u8, 0x65u8,
-     0x3bu8, 0x95u8, 0xecu8, 0xc5u8, 0x47u8, 0x4du8, 0xeeu8, 0x8bu8,
-     0x99u8, 0x46u8, 0x10u8, 0x08u8, 0xd2u8, 0x6du8, 0x80u8, 0xcau8,
-     0x38u8, 0x4fu8, 0x1eu8, 0x59u8, 0xe9u8, 0x27u8, 0x71u8, 0x4du8])
+    store([0x35u8, 0xe1u8, 0xccu8, 0x80u8, 0x9fu8, 0x6fu8, 0x07u8, 0x65u8,
+     0x21u8, 0xa4u8, 0x3fu8, 0x85u8, 0x06u8, 0x8du8, 0x55u8, 0x92u8,
+     0x22u8, 0x04u8, 0x07u8, 0xc0u8, 0x53u8, 0x2bu8, 0x6au8, 0x08u8,
+     0x95u8, 0x2fu8, 0x40u8, 0xd8u8, 0x52u8, 0x3du8, 0x04u8, 0xbcu8])
   }
 
   fn str_addr() -> Addr {
-    store([0x42u8, 0x88u8, 0xf9u8, 0x2eu8, 0xd1u8, 0xd5u8, 0x1fu8, 0x49u8,
-     0x35u8, 0xe5u8, 0xd2u8, 0x77u8, 0x5fu8, 0x33u8, 0xecu8, 0x58u8,
-     0x5du8, 0x6fu8, 0xe5u8, 0xecu8, 0x63u8, 0xdau8, 0xdfu8, 0x0eu8,
-     0xa6u8, 0x98u8, 0x55u8, 0x44u8, 0x78u8, 0xfdu8, 0x9fu8, 0xadu8])
+    store([0x9du8, 0x6au8, 0xe4u8, 0x34u8, 0x29u8, 0xecu8, 0x02u8, 0xa9u8,
+     0x33u8, 0x8bu8, 0xbcu8, 0xd0u8, 0xdbu8, 0x0au8, 0xc1u8, 0x93u8,
+     0xd7u8, 0x5eu8, 0xbdu8, 0x46u8, 0xf8u8, 0x84u8, 0xbfu8, 0xcbu8,
+     0xd2u8, 0xc4u8, 0x2bu8, 0xf7u8, 0xfau8, 0xeau8, 0x15u8, 0x0du8])
   }
 
   fn k_infer_lit(lit: KLiteral) -> KExpr {
@@ -596,66 +596,66 @@ def infer := ⟦
   -- ============================================================================
 
   fn nat_dec_le_addr_dec() -> Addr {
-    store([0x29u8, 0x99u8, 0x80u8, 0x15u8, 0x98u8, 0xc1u8, 0xdau8, 0x48u8,
-     0xf5u8, 0x62u8, 0xd4u8, 0x83u8, 0x60u8, 0x64u8, 0xf6u8, 0x35u8,
-     0xc0u8, 0x45u8, 0xd0u8, 0x52u8, 0x14u8, 0x52u8, 0xb5u8, 0xe7u8,
-     0x4au8, 0x12u8, 0xbfu8, 0x99u8, 0xd2u8, 0xe3u8, 0x16u8, 0xecu8])
+    store([0xf0u8, 0xf1u8, 0x5eu8, 0xd0u8, 0x79u8, 0x82u8, 0x2fu8, 0x06u8,
+     0xe8u8, 0x2eu8, 0x36u8, 0x66u8, 0x4bu8, 0xf6u8, 0x1eu8, 0x79u8,
+     0x7eu8, 0x5bu8, 0x1eu8, 0x7bu8, 0x0bu8, 0x41u8, 0x55u8, 0x15u8,
+     0x27u8, 0x62u8, 0xc5u8, 0x13u8, 0x27u8, 0x4bu8, 0xfeu8, 0xe1u8])
   }
 
   fn nat_dec_eq_addr_dec() -> Addr {
-    store([0x1bu8, 0xacu8, 0x04u8, 0x17u8, 0x56u8, 0xedu8, 0x22u8, 0xd7u8,
-     0x3bu8, 0xbcu8, 0xacu8, 0x84u8, 0x9au8, 0x94u8, 0xf2u8, 0x46u8,
-     0xeeu8, 0x26u8, 0x96u8, 0x99u8, 0x9fu8, 0xafu8, 0x35u8, 0x19u8,
-     0x40u8, 0x46u8, 0x8du8, 0x96u8, 0x29u8, 0x70u8, 0xcau8, 0x2au8])
+    store([0x8au8, 0x5du8, 0x5eu8, 0xeeu8, 0x41u8, 0x4au8, 0x2fu8, 0xa5u8,
+     0x95u8, 0x6bu8, 0x74u8, 0xe8u8, 0x32u8, 0x3au8, 0x20u8, 0x50u8,
+     0x8du8, 0x77u8, 0x4eu8, 0xd1u8, 0xb5u8, 0x60u8, 0x3fu8, 0x55u8,
+     0xe7u8, 0x74u8, 0xadu8, 0x89u8, 0x6bu8, 0xd3u8, 0xe6u8, 0xe7u8])
   }
 
   fn nat_dec_lt_addr_dec() -> Addr {
-    store([0x12u8, 0xf3u8, 0x86u8, 0xf4u8, 0x86u8, 0x91u8, 0x3bu8, 0x11u8,
-     0xb5u8, 0x47u8, 0x3cu8, 0xb2u8, 0x53u8, 0x83u8, 0x30u8, 0xd5u8,
-     0x1fu8, 0x25u8, 0xaeu8, 0xecu8, 0x7fu8, 0x2du8, 0x7du8, 0x6bu8,
-     0x96u8, 0x90u8, 0x43u8, 0x29u8, 0xc7u8, 0x8bu8, 0x69u8, 0x67u8])
+    store([0x7cu8, 0x49u8, 0x77u8, 0x19u8, 0x6eu8, 0x95u8, 0xbeu8, 0x2au8,
+     0x75u8, 0x9fu8, 0xc9u8, 0xc6u8, 0xd1u8, 0x53u8, 0x3du8, 0xb8u8,
+     0xdau8, 0x49u8, 0x59u8, 0x2fu8, 0x06u8, 0x41u8, 0x9bu8, 0x15u8,
+     0x5du8, 0x88u8, 0x83u8, 0x33u8, 0xc8u8, 0xddu8, 0x89u8, 0x31u8])
   }
 
   fn decidable_is_true_addr_dec() -> Addr {
-    store([0x7bu8, 0x3fu8, 0x6au8, 0x6eu8, 0xebu8, 0xf3u8, 0x2au8, 0x9du8,
-     0x5au8, 0x54u8, 0x30u8, 0x5eu8, 0x69u8, 0x3du8, 0xceu8, 0x60u8,
-     0x51u8, 0x1au8, 0xfeu8, 0xb1u8, 0xfau8, 0x11u8, 0xbcu8, 0x88u8,
-     0x44u8, 0xa5u8, 0xc2u8, 0x1bu8, 0xbfu8, 0xd3u8, 0x21u8, 0x4cu8])
+    store([0x36u8, 0x3du8, 0x07u8, 0x11u8, 0x82u8, 0xbeu8, 0x41u8, 0x4eu8,
+     0x1au8, 0x58u8, 0x59u8, 0x9bu8, 0x83u8, 0xf5u8, 0xe1u8, 0x9fu8,
+     0x9bu8, 0x87u8, 0x37u8, 0x23u8, 0x05u8, 0x4fu8, 0x42u8, 0x87u8,
+     0xbau8, 0x69u8, 0x70u8, 0x5au8, 0xafu8, 0xefu8, 0x27u8, 0xdau8])
   }
 
   fn decidable_is_false_addr_dec() -> Addr {
-    store([0xabu8, 0x14u8, 0x70u8, 0x19u8, 0x64u8, 0x19u8, 0xf7u8, 0x1du8,
-     0x06u8, 0xfeu8, 0xedu8, 0x9cu8, 0xcbu8, 0x8cu8, 0x1du8, 0x03u8,
-     0x67u8, 0x45u8, 0x28u8, 0xecu8, 0x03u8, 0x01u8, 0x2bu8, 0x09u8,
-     0x5bu8, 0xadu8, 0xc1u8, 0x69u8, 0xd4u8, 0x8du8, 0x03u8, 0xd0u8])
+    store([0x8cu8, 0xc0u8, 0xe1u8, 0x36u8, 0x0cu8, 0x1bu8, 0x29u8, 0x10u8,
+     0x8du8, 0xabu8, 0x3du8, 0x61u8, 0x72u8, 0xe7u8, 0xfcu8, 0xe8u8,
+     0xa9u8, 0xaau8, 0x96u8, 0x40u8, 0xdau8, 0xa4u8, 0xbbu8, 0xe9u8,
+     0x9bu8, 0xa1u8, 0x30u8, 0x5du8, 0x96u8, 0x23u8, 0x62u8, 0x4bu8])
   }
 
   fn nat_le_of_ble_eq_true_addr_dec() -> Addr {
-    store([0x23u8, 0xbeu8, 0xa3u8, 0xbbu8, 0xf3u8, 0xa8u8, 0xd0u8, 0xa8u8,
-     0xd0u8, 0x03u8, 0x3cu8, 0xf7u8, 0xe5u8, 0x6au8, 0xf0u8, 0xc4u8,
-     0xaeu8, 0xe0u8, 0x15u8, 0x82u8, 0xd5u8, 0xa7u8, 0x58u8, 0xc0u8,
-     0xdfu8, 0x56u8, 0x15u8, 0x92u8, 0x9cu8, 0xa6u8, 0x20u8, 0x4du8])
+    store([0xadu8, 0x25u8, 0xbfu8, 0xd2u8, 0x07u8, 0xbau8, 0xe8u8, 0x32u8,
+     0xc7u8, 0x3du8, 0x5cu8, 0xe6u8, 0x14u8, 0xbeu8, 0xadu8, 0x22u8,
+     0xefu8, 0x98u8, 0x62u8, 0xe1u8, 0x10u8, 0xf8u8, 0xd1u8, 0x7au8,
+     0x50u8, 0x64u8, 0xffu8, 0xb7u8, 0x60u8, 0x3eu8, 0xeeu8, 0x3du8])
   }
 
   fn nat_not_le_of_not_ble_eq_true_addr_dec() -> Addr {
-    store([0xbeu8, 0x50u8, 0xb6u8, 0x05u8, 0x3du8, 0xf0u8, 0xb0u8, 0x74u8,
-     0x38u8, 0xa4u8, 0xacu8, 0x2eu8, 0xefu8, 0xd7u8, 0x0au8, 0x11u8,
-     0x70u8, 0x8bu8, 0x0cu8, 0xbbu8, 0x0fu8, 0xc9u8, 0x05u8, 0x64u8,
-     0xbau8, 0xfeu8, 0xe6u8, 0xe1u8, 0x65u8, 0x61u8, 0x5du8, 0xe8u8])
+    store([0xe3u8, 0x65u8, 0x8fu8, 0x50u8, 0xdcu8, 0x51u8, 0x23u8, 0xefu8,
+     0xffu8, 0x21u8, 0x35u8, 0x88u8, 0xdeu8, 0xe3u8, 0xd4u8, 0xc6u8,
+     0x06u8, 0x3fu8, 0x5eu8, 0xdbu8, 0x18u8, 0x95u8, 0x08u8, 0x50u8,
+     0xacu8, 0x04u8, 0x90u8, 0xc9u8, 0x37u8, 0x81u8, 0x90u8, 0x09u8])
   }
 
   fn nat_eq_of_beq_eq_true_addr_dec() -> Addr {
-    store([0xc4u8, 0x89u8, 0x32u8, 0x91u8, 0x97u8, 0xb5u8, 0x9au8, 0x04u8,
-     0x0du8, 0x1eu8, 0x5eu8, 0x4du8, 0x5du8, 0xe6u8, 0xa7u8, 0x70u8,
-     0x47u8, 0x8du8, 0x1eu8, 0xa4u8, 0xf9u8, 0x75u8, 0x01u8, 0x76u8,
-     0x02u8, 0x6du8, 0xd2u8, 0xbfu8, 0x85u8, 0x93u8, 0xbfu8, 0x22u8])
+    store([0x9cu8, 0x91u8, 0xe7u8, 0x9du8, 0xe7u8, 0x32u8, 0x22u8, 0x6bu8,
+     0xa2u8, 0xe7u8, 0x3cu8, 0xbdu8, 0xd3u8, 0x30u8, 0x85u8, 0x1bu8,
+     0xaeu8, 0xc4u8, 0x06u8, 0x68u8, 0xebu8, 0x40u8, 0xc6u8, 0xf3u8,
+     0x2au8, 0xa2u8, 0xf8u8, 0xdau8, 0xc5u8, 0xa0u8, 0x4bu8, 0x51u8])
   }
 
   fn nat_ne_of_beq_eq_false_addr_dec() -> Addr {
-    store([0x0eu8, 0xb5u8, 0xb9u8, 0x87u8, 0xf1u8, 0x21u8, 0x24u8, 0xbeu8,
-     0x05u8, 0x75u8, 0xa4u8, 0x77u8, 0xccu8, 0x0au8, 0x53u8, 0x55u8,
-     0x16u8, 0xa2u8, 0x4bu8, 0x0au8, 0xe5u8, 0xceu8, 0xddu8, 0xbeu8,
-     0xe2u8, 0xd4u8, 0x72u8, 0x76u8, 0x5au8, 0xedu8, 0x29u8, 0x9cu8])
+    store([0xa0u8, 0x7du8, 0xb5u8, 0x32u8, 0x74u8, 0x7eu8, 0x65u8, 0xeeu8,
+     0x77u8, 0xa7u8, 0xbau8, 0x01u8, 0x50u8, 0x69u8, 0xbdu8, 0xbau8,
+     0xf1u8, 0xf7u8, 0x09u8, 0xceu8, 0x0du8, 0x60u8, 0xb8u8, 0x3cu8,
+     0x94u8, 0xf4u8, 0x0du8, 0x0eu8, 0x5eu8, 0x57u8, 0x59u8, 0x5au8])
   }
 
   fn bool_type_addr_dec() -> Addr {
@@ -666,45 +666,45 @@ def infer := ⟦
   }
 
   fn eq_refl_addr_dec() -> Addr {
-    store([0xe3u8, 0x08u8, 0x03u8, 0x5bu8, 0xdfu8, 0x28u8, 0x0cu8, 0x92u8,
-     0x75u8, 0x56u8, 0x82u8, 0x4du8, 0x6au8, 0x9fu8, 0x92u8, 0x36u8,
-     0xa1u8, 0x48u8, 0x76u8, 0x51u8, 0xf0u8, 0x05u8, 0x9au8, 0x7du8,
-     0xf3u8, 0xbdu8, 0xa8u8, 0x5bu8, 0x33u8, 0x1fu8, 0x67u8, 0xe6u8])
+    store([0xd4u8, 0x94u8, 0xdcu8, 0x60u8, 0x13u8, 0x86u8, 0xbau8, 0x8eu8,
+     0x8fu8, 0x0bu8, 0x71u8, 0x1fu8, 0xe6u8, 0x2au8, 0x2du8, 0x60u8,
+     0xabu8, 0x60u8, 0xc6u8, 0x48u8, 0x8cu8, 0x8cu8, 0xf6u8, 0xceu8,
+     0x97u8, 0x79u8, 0x6eu8, 0xbcu8, 0x3au8, 0xd5u8, 0xfeu8, 0xfbu8])
   }
 
   fn int_dec_eq_addr_dec() -> Addr {
-    store([0x7au8, 0x06u8, 0x49u8, 0x6du8, 0x07u8, 0xb5u8, 0x97u8, 0x10u8,
-     0x34u8, 0x8au8, 0x5fu8, 0x65u8, 0x78u8, 0x51u8, 0xa4u8, 0xeeu8,
-     0xa1u8, 0xf5u8, 0x94u8, 0x92u8, 0xa5u8, 0xb7u8, 0xdeu8, 0x3fu8,
-     0x51u8, 0xabu8, 0xbcu8, 0x84u8, 0xf9u8, 0xbcu8, 0x1du8, 0x17u8])
+    store([0xfcu8, 0x8cu8, 0x44u8, 0xccu8, 0x97u8, 0x0cu8, 0xfcu8, 0x18u8,
+     0x3cu8, 0xcdu8, 0x10u8, 0xa2u8, 0xd1u8, 0xcdu8, 0xebu8, 0x2cu8,
+     0x84u8, 0x93u8, 0x07u8, 0x76u8, 0x0eu8, 0x91u8, 0xf5u8, 0xcdu8,
+     0x29u8, 0xa2u8, 0xb0u8, 0x2fu8, 0x70u8, 0x6du8, 0x83u8, 0xdau8])
   }
 
   fn int_dec_le_addr_dec() -> Addr {
-    store([0x14u8, 0xecu8, 0xceu8, 0xe1u8, 0xdeu8, 0xbau8, 0x05u8, 0xe9u8,
-     0x44u8, 0x3bu8, 0xd1u8, 0x69u8, 0xd0u8, 0x0eu8, 0xd6u8, 0x34u8,
-     0x17u8, 0x0eu8, 0x32u8, 0x46u8, 0xb3u8, 0x79u8, 0x21u8, 0x19u8,
-     0x9eu8, 0xdbu8, 0xbau8, 0xd3u8, 0xf6u8, 0x7du8, 0xb5u8, 0xb4u8])
+    store([0xfcu8, 0xdfu8, 0x18u8, 0x60u8, 0xadu8, 0x4cu8, 0xd6u8, 0x72u8,
+     0x23u8, 0x93u8, 0x92u8, 0xe6u8, 0x0eu8, 0x7bu8, 0x49u8, 0xe0u8,
+     0x24u8, 0xafu8, 0x04u8, 0x75u8, 0x73u8, 0x9cu8, 0x3au8, 0x40u8,
+     0x19u8, 0x5au8, 0x91u8, 0x4eu8, 0xaeu8, 0xc4u8, 0x2cu8, 0x04u8])
   }
 
   fn int_dec_lt_addr_dec() -> Addr {
-    store([0xadu8, 0x32u8, 0xc0u8, 0x5du8, 0x7eu8, 0x3cu8, 0x5du8, 0xdfu8,
-     0x4eu8, 0x4cu8, 0x85u8, 0xcfu8, 0x8fu8, 0x60u8, 0xd8u8, 0x3eu8,
-     0x0fu8, 0xbau8, 0x55u8, 0xe2u8, 0x67u8, 0x6bu8, 0xf8u8, 0xa1u8,
-     0xe6u8, 0x08u8, 0xdbu8, 0x54u8, 0xb1u8, 0x67u8, 0xc9u8, 0xfau8])
+    store([0x1du8, 0x54u8, 0x80u8, 0x6au8, 0xb1u8, 0xebu8, 0xc7u8, 0x91u8,
+     0xe1u8, 0xdbu8, 0x96u8, 0xe8u8, 0x8du8, 0x04u8, 0x07u8, 0xceu8,
+     0xf3u8, 0x52u8, 0x39u8, 0x27u8, 0xd6u8, 0x0bu8, 0xa6u8, 0x69u8,
+     0x68u8, 0x9bu8, 0x92u8, 0xa8u8, 0xeeu8, 0xb3u8, 0x64u8, 0x45u8])
   }
 
   fn int_of_nat_addr_dec() -> Addr {
-    store([0x48u8, 0x78u8, 0x6bu8, 0x7fu8, 0x7au8, 0xdcu8, 0x63u8, 0x2au8,
-     0xe3u8, 0x50u8, 0x59u8, 0xf3u8, 0xfdu8, 0x18u8, 0x1du8, 0xf3u8,
-     0x2du8, 0x9eu8, 0x5cu8, 0xc7u8, 0x36u8, 0x0cu8, 0x4fu8, 0xd0u8,
-     0x2cu8, 0x3eu8, 0x8bu8, 0x11u8, 0x81u8, 0xa1u8, 0x53u8, 0x9bu8])
+    store([0x0au8, 0x99u8, 0xf4u8, 0x9cu8, 0xc7u8, 0x3au8, 0xb9u8, 0xf4u8,
+     0x27u8, 0x83u8, 0x09u8, 0x2eu8, 0x71u8, 0x20u8, 0x61u8, 0x32u8,
+     0x25u8, 0x67u8, 0x0bu8, 0xabu8, 0x89u8, 0xb9u8, 0xd6u8, 0x35u8,
+     0x33u8, 0xd1u8, 0xadu8, 0xefu8, 0xc8u8, 0x76u8, 0x18u8, 0x2fu8])
   }
 
   fn int_neg_succ_addr_dec() -> Addr {
-    store([0xcfu8, 0xc9u8, 0x34u8, 0xfdu8, 0x6du8, 0x53u8, 0xa5u8, 0xb2u8,
-     0x3bu8, 0x6au8, 0x3bu8, 0x30u8, 0xd0u8, 0x21u8, 0x65u8, 0xfdu8,
-     0xaau8, 0x57u8, 0x4eu8, 0x3bu8, 0x5eu8, 0xb1u8, 0x39u8, 0x26u8,
-     0xbbu8, 0x16u8, 0x6eu8, 0x64u8, 0x86u8, 0xfcu8, 0x0eu8, 0x50u8])
+    store([0xf7u8, 0x13u8, 0x0du8, 0x58u8, 0x64u8, 0xe1u8, 0xbau8, 0x77u8,
+     0xb0u8, 0xf6u8, 0xa7u8, 0x33u8, 0x8fu8, 0x92u8, 0x15u8, 0x9cu8,
+     0x35u8, 0xbdu8, 0x51u8, 0x47u8, 0xe0u8, 0xfeu8, 0xbcu8, 0xf1u8,
+     0xebu8, 0xedu8, 0x45u8, 0x6eu8, 0x51u8, 0x35u8, 0x38u8, 0xccu8])
   }
 
   fn is_dec_prim_addr(a: Addr) -> G {
@@ -1050,3 +1050,4 @@ def infer := ⟦
 end IxVM
 
 end
+
diff --git a/Ix/IxVM/Kernel/InferOnly.lean b/Ix/IxVM/Kernel/InferOnly.lean
index 43ef225b7..c6df98f1a 100644
--- a/Ix/IxVM/Kernel/InferOnly.lean
+++ b/Ix/IxVM/Kernel/InferOnly.lean
@@ -59,17 +59,17 @@ def inferOnly := ⟦
   }
 
   fn nat_addr_io() -> Addr {
-    store([0x1du8, 0xffu8, 0xfdu8, 0xe4u8, 0x8cu8, 0x4eu8, 0xf6u8, 0x65u8,
-     0x3bu8, 0x95u8, 0xecu8, 0xc5u8, 0x47u8, 0x4du8, 0xeeu8, 0x8bu8,
-     0x99u8, 0x46u8, 0x10u8, 0x08u8, 0xd2u8, 0x6du8, 0x80u8, 0xcau8,
-     0x38u8, 0x4fu8, 0x1eu8, 0x59u8, 0xe9u8, 0x27u8, 0x71u8, 0x4du8])
+    store([0x35u8, 0xe1u8, 0xccu8, 0x80u8, 0x9fu8, 0x6fu8, 0x07u8, 0x65u8,
+     0x21u8, 0xa4u8, 0x3fu8, 0x85u8, 0x06u8, 0x8du8, 0x55u8, 0x92u8,
+     0x22u8, 0x04u8, 0x07u8, 0xc0u8, 0x53u8, 0x2bu8, 0x6au8, 0x08u8,
+     0x95u8, 0x2fu8, 0x40u8, 0xd8u8, 0x52u8, 0x3du8, 0x04u8, 0xbcu8])
   }
 
   fn str_addr_io() -> Addr {
-    store([0x42u8, 0x88u8, 0xf9u8, 0x2eu8, 0xd1u8, 0xd5u8, 0x1fu8, 0x49u8,
-     0x35u8, 0xe5u8, 0xd2u8, 0x77u8, 0x5fu8, 0x33u8, 0xecu8, 0x58u8,
-     0x5du8, 0x6fu8, 0xe5u8, 0xecu8, 0x63u8, 0xdau8, 0xdfu8, 0x0eu8,
-     0xa6u8, 0x98u8, 0x55u8, 0x44u8, 0x78u8, 0xfdu8, 0x9fu8, 0xadu8])
+    store([0x9du8, 0x6au8, 0xe4u8, 0x34u8, 0x29u8, 0xecu8, 0x02u8, 0xa9u8,
+     0x33u8, 0x8bu8, 0xbcu8, 0xd0u8, 0xdbu8, 0x0au8, 0xc1u8, 0x93u8,
+     0xd7u8, 0x5eu8, 0xbdu8, 0x46u8, 0xf8u8, 0x84u8, 0xbfu8, 0xcbu8,
+     0xd2u8, 0xc4u8, 0x2bu8, 0xf7u8, 0xfau8, 0xeau8, 0x15u8, 0x0du8])
   }
 
   -- k_infer_only: type-synthesis-only (mirror Rust `with_infer_only`).
@@ -241,3 +241,4 @@ def inferOnly := ⟦
 end IxVM
 
 end
+
diff --git a/Ix/IxVM/Kernel/NatPrim.lean b/Ix/IxVM/Kernel/NatPrim.lean
index b8416b197..09027e7aa 100644
--- a/Ix/IxVM/Kernel/NatPrim.lean
+++ b/Ix/IxVM/Kernel/NatPrim.lean
@@ -39,136 +39,136 @@ def natPrim := ⟦
   -- Primitive canonical addresses. Guarded by Tests/Ix/Kernel/PrimAddrs.lean.
   -- ============================================================================
   fn nat_zero_addr() -> Addr {
-    store([0x50u8, 0xe5u8, 0xd6u8, 0x9du8, 0x80u8, 0x6bu8, 0xc1u8, 0xc6u8,
-     0x16u8, 0xcau8, 0xceu8, 0x42u8, 0x30u8, 0xc9u8, 0x82u8, 0xa0u8,
-     0xeeu8, 0x5bu8, 0x35u8, 0x0bu8, 0x3eu8, 0xfeu8, 0x3bu8, 0x1au8,
-     0x15u8, 0x80u8, 0x1du8, 0xf7u8, 0x7fu8, 0xc0u8, 0x0cu8, 0x8cu8])
+    store([0xeeu8, 0xb2u8, 0xe6u8, 0x26u8, 0x8fu8, 0xf6u8, 0xd0u8, 0xe6u8,
+     0xb2u8, 0xe9u8, 0x76u8, 0x4du8, 0x99u8, 0x40u8, 0xb8u8, 0x1bu8,
+     0xb6u8, 0x4bu8, 0x9fu8, 0x8fu8, 0x4bu8, 0x13u8, 0x58u8, 0xd2u8,
+     0x94u8, 0xffu8, 0x98u8, 0x17u8, 0xe6u8, 0x94u8, 0x1au8, 0x46u8])
   }
 
   fn nat_succ_addr() -> Addr {
-    store([0x8cu8, 0x09u8, 0xcau8, 0x64u8, 0x4bu8, 0x10u8, 0xdeu8, 0xcau8,
-     0xd1u8, 0x58u8, 0xd3u8, 0x70u8, 0x06u8, 0xe8u8, 0x1cu8, 0xdcu8,
-     0x1bu8, 0x84u8, 0x76u8, 0x13u8, 0x12u8, 0x26u8, 0x05u8, 0x46u8,
-     0x44u8, 0x9au8, 0xa0u8, 0x2eu8, 0x34u8, 0x3bu8, 0x2bu8, 0x0cu8])
+    store([0x42u8, 0xd6u8, 0xedu8, 0x31u8, 0x53u8, 0x6fu8, 0x09u8, 0x58u8,
+     0x17u8, 0x6fu8, 0x1du8, 0xc9u8, 0x73u8, 0x38u8, 0x38u8, 0x08u8,
+     0xacu8, 0x85u8, 0x83u8, 0x22u8, 0x37u8, 0x46u8, 0xebu8, 0xcau8,
+     0x78u8, 0xdbu8, 0xe3u8, 0x89u8, 0xb6u8, 0x53u8, 0x21u8, 0xa6u8])
   }
 
   fn nat_pred_addr() -> Addr {
-    store([0xfcu8, 0xe9u8, 0x16u8, 0xcfu8, 0x3cu8, 0x6du8, 0xd0u8, 0x1au8,
-     0xd8u8, 0xc6u8, 0xd3u8, 0x86u8, 0x41u8, 0xbcu8, 0xa7u8, 0xb3u8,
-     0xeeu8, 0xacu8, 0x5bu8, 0xc9u8, 0x3bu8, 0x35u8, 0x29u8, 0xadu8,
-     0x78u8, 0x12u8, 0x76u8, 0x8bu8, 0x34u8, 0x07u8, 0xd6u8, 0x4eu8])
-  }
-
-  fn int_of_nat_addr() -> Addr { store([0x48u8, 0x78u8, 0x6bu8, 0x7fu8, 0x7au8, 0xdcu8, 0x63u8, 0x2au8, 0xe3u8, 0x50u8, 0x59u8, 0xf3u8, 0xfdu8, 0x18u8, 0x1du8, 0xf3u8, 0x2du8, 0x9eu8, 0x5cu8, 0xc7u8, 0x36u8, 0x0cu8, 0x4fu8, 0xd0u8, 0x2cu8, 0x3eu8, 0x8bu8, 0x11u8, 0x81u8, 0xa1u8, 0x53u8, 0x9bu8]) }
-  fn int_neg_succ_addr() -> Addr { store([0xcfu8, 0xc9u8, 0x34u8, 0xfdu8, 0x6du8, 0x53u8, 0xa5u8, 0xb2u8, 0x3bu8, 0x6au8, 0x3bu8, 0x30u8, 0xd0u8, 0x21u8, 0x65u8, 0xfdu8, 0xaau8, 0x57u8, 0x4eu8, 0x3bu8, 0x5eu8, 0xb1u8, 0x39u8, 0x26u8, 0xbbu8, 0x16u8, 0x6eu8, 0x64u8, 0x86u8, 0xfcu8, 0x0eu8, 0x50u8]) }
-  fn int_add_addr() -> Addr { store([0x1eu8, 0x60u8, 0xbdu8, 0x37u8, 0x7au8, 0x74u8, 0x6cu8, 0xb7u8, 0xbdu8, 0x7au8, 0xe5u8, 0x41u8, 0xd7u8, 0xdfu8, 0xb2u8, 0x37u8, 0x09u8, 0x7du8, 0x88u8, 0x3du8, 0x28u8, 0xecu8, 0x7au8, 0xadu8, 0xd7u8, 0x32u8, 0xc0u8, 0x67u8, 0x4eu8, 0x0du8, 0xb9u8, 0x64u8]) }
-  fn int_sub_addr() -> Addr { store([0x0du8, 0x74u8, 0xbau8, 0x85u8, 0xf9u8, 0x74u8, 0x9au8, 0x0cu8, 0x25u8, 0xaau8, 0x6au8, 0x2bu8, 0x70u8, 0x34u8, 0x8eu8, 0x57u8, 0xe7u8, 0x09u8, 0x83u8, 0x1fu8, 0xb7u8, 0xccu8, 0x05u8, 0x22u8, 0x9fu8, 0xecu8, 0xd7u8, 0xd6u8, 0x6au8, 0xdfu8, 0x18u8, 0x4du8]) }
-  fn int_mul_addr() -> Addr { store([0xc5u8, 0xbeu8, 0xf6u8, 0xbeu8, 0x6cu8, 0x3fu8, 0xdcu8, 0x52u8, 0x04u8, 0x54u8, 0xc1u8, 0x1eu8, 0x99u8, 0x50u8, 0xebu8, 0x2fu8, 0x1au8, 0x6cu8, 0x92u8, 0xf4u8, 0x1au8, 0x64u8, 0x6bu8, 0x5cu8, 0xa1u8, 0x68u8, 0xffu8, 0x19u8, 0x8fu8, 0x13u8, 0xc5u8, 0x5au8]) }
-  fn int_neg_addr() -> Addr { store([0xbcu8, 0x61u8, 0xc1u8, 0x0fu8, 0xccu8, 0xa6u8, 0x41u8, 0x52u8, 0x23u8, 0xedu8, 0x97u8, 0xbcu8, 0xaeu8, 0x21u8, 0xcbu8, 0x99u8, 0xd4u8, 0x83u8, 0x6du8, 0x07u8, 0x7bu8, 0x07u8, 0x86u8, 0xa2u8, 0xfcu8, 0x5cu8, 0x59u8, 0x05u8, 0xf8u8, 0xb0u8, 0x4bu8, 0xa2u8]) }
-  fn int_emod_addr() -> Addr { store([0xd4u8, 0x35u8, 0xa1u8, 0x5eu8, 0x6fu8, 0x22u8, 0x2fu8, 0x78u8, 0x6bu8, 0x61u8, 0x30u8, 0xfau8, 0x76u8, 0x4cu8, 0x7fu8, 0xbeu8, 0x98u8, 0x74u8, 0x6fu8, 0x79u8, 0x8eu8, 0x97u8, 0xa6u8, 0x27u8, 0xa6u8, 0x23u8, 0x7au8, 0x17u8, 0xe7u8, 0x4fu8, 0x72u8, 0x27u8]) }
-  fn int_ediv_addr() -> Addr { store([0x3eu8, 0x13u8, 0xfcu8, 0x1au8, 0x07u8, 0x7eu8, 0xb6u8, 0x92u8, 0xafu8, 0x40u8, 0xacu8, 0xbeu8, 0xd4u8, 0xa6u8, 0xadu8, 0xaeu8, 0x25u8, 0x5cu8, 0x0cu8, 0xbbu8, 0xbau8, 0x9au8, 0x3cu8, 0x1fu8, 0x0du8, 0xe2u8, 0x95u8, 0x73u8, 0xb1u8, 0x97u8, 0xcbu8, 0x0eu8]) }
-  fn int_bmod_addr() -> Addr { store([0x99u8, 0x70u8, 0xf4u8, 0x02u8, 0xc8u8, 0x70u8, 0xe8u8, 0xa3u8, 0x14u8, 0x6fu8, 0xbfu8, 0x4bu8, 0x76u8, 0xf9u8, 0x49u8, 0xaau8, 0x64u8, 0xb2u8, 0x06u8, 0xdeu8, 0x9bu8, 0x01u8, 0x57u8, 0xb4u8, 0x69u8, 0xfdu8, 0xe3u8, 0x57u8, 0xb7u8, 0x15u8, 0xf1u8, 0x9cu8]) }
-  fn int_bdiv_addr() -> Addr { store([0x86u8, 0x7fu8, 0x8eu8, 0x9du8, 0xfbu8, 0x75u8, 0x22u8, 0x65u8, 0xbau8, 0x47u8, 0x42u8, 0x36u8, 0x8bu8, 0x6au8, 0xfau8, 0x54u8, 0x6au8, 0xe4u8, 0xe2u8, 0x40u8, 0xfcu8, 0x5au8, 0xc6u8, 0x9bu8, 0x4au8, 0x4eu8, 0x86u8, 0xd8u8, 0x5au8, 0x6eu8, 0x46u8, 0xf6u8]) }
-  fn int_nat_abs_addr() -> Addr { store([0x21u8, 0xd4u8, 0xdau8, 0xccu8, 0x0fu8, 0x40u8, 0x6bu8, 0x31u8, 0xe0u8, 0x44u8, 0xfbu8, 0xf4u8, 0xd8u8, 0x98u8, 0x7au8, 0x33u8, 0x2du8, 0xd8u8, 0xb4u8, 0x24u8, 0x4fu8, 0x7du8, 0x9eu8, 0x62u8, 0xb0u8, 0x86u8, 0x50u8, 0x14u8, 0x74u8, 0x82u8, 0x55u8, 0x44u8]) }
-  fn int_pow_addr() -> Addr { store([0x87u8, 0x85u8, 0x99u8, 0xe9u8, 0xf5u8, 0xbbu8, 0xccu8, 0xb9u8, 0x42u8, 0x23u8, 0x2fu8, 0xf9u8, 0x3bu8, 0x62u8, 0xc6u8, 0x3du8, 0xb4u8, 0xebu8, 0xdfu8, 0x62u8, 0xb9u8, 0xf9u8, 0x23u8, 0x79u8, 0x00u8, 0xa3u8, 0x70u8, 0x49u8, 0xf4u8, 0x22u8, 0xadu8, 0x86u8]) }
+    store([0x76u8, 0xafu8, 0xa2u8, 0x54u8, 0xa8u8, 0xbbu8, 0xf2u8, 0xacu8,
+     0x43u8, 0x27u8, 0xd7u8, 0xb9u8, 0x4bu8, 0xe0u8, 0xc6u8, 0x3bu8,
+     0xd7u8, 0x08u8, 0x83u8, 0x6bu8, 0x5fu8, 0x73u8, 0x84u8, 0xceu8,
+     0x99u8, 0x03u8, 0x88u8, 0xadu8, 0xb0u8, 0xa1u8, 0xd3u8, 0xcfu8])
+  }
+
+  fn int_of_nat_addr() -> Addr { store([0x0au8, 0x99u8, 0xf4u8, 0x9cu8, 0xc7u8, 0x3au8, 0xb9u8, 0xf4u8, 0x27u8, 0x83u8, 0x09u8, 0x2eu8, 0x71u8, 0x20u8, 0x61u8, 0x32u8, 0x25u8, 0x67u8, 0x0bu8, 0xabu8, 0x89u8, 0xb9u8, 0xd6u8, 0x35u8, 0x33u8, 0xd1u8, 0xadu8, 0xefu8, 0xc8u8, 0x76u8, 0x18u8, 0x2fu8]) }
+  fn int_neg_succ_addr() -> Addr { store([0xf7u8, 0x13u8, 0x0du8, 0x58u8, 0x64u8, 0xe1u8, 0xbau8, 0x77u8, 0xb0u8, 0xf6u8, 0xa7u8, 0x33u8, 0x8fu8, 0x92u8, 0x15u8, 0x9cu8, 0x35u8, 0xbdu8, 0x51u8, 0x47u8, 0xe0u8, 0xfeu8, 0xbcu8, 0xf1u8, 0xebu8, 0xedu8, 0x45u8, 0x6eu8, 0x51u8, 0x35u8, 0x38u8, 0xccu8]) }
+  fn int_add_addr() -> Addr { store([0x9du8, 0xb0u8, 0x17u8, 0x7eu8, 0x4eu8, 0x8bu8, 0x6au8, 0x0eu8, 0x73u8, 0x23u8, 0x06u8, 0x95u8, 0x09u8, 0xc2u8, 0x45u8, 0x7du8, 0xe9u8, 0x59u8, 0x8au8, 0x7eu8, 0x38u8, 0xe7u8, 0x2fu8, 0xfeu8, 0x19u8, 0xadu8, 0x34u8, 0x61u8, 0x72u8, 0x56u8, 0xe1u8, 0x0du8]) }
+  fn int_sub_addr() -> Addr { store([0x85u8, 0x62u8, 0x13u8, 0x87u8, 0xefu8, 0x30u8, 0x27u8, 0x02u8, 0x8du8, 0x83u8, 0x52u8, 0x87u8, 0xf3u8, 0xccu8, 0x14u8, 0x61u8, 0xefu8, 0x04u8, 0x1du8, 0xefu8, 0x1fu8, 0xd9u8, 0x1eu8, 0x28u8, 0xe8u8, 0x7fu8, 0x66u8, 0x9cu8, 0xc0u8, 0x4au8, 0x5eu8, 0xeau8]) }
+  fn int_mul_addr() -> Addr { store([0xb0u8, 0x54u8, 0x59u8, 0x62u8, 0x3du8, 0x23u8, 0x29u8, 0x9du8, 0x3au8, 0x84u8, 0x9eu8, 0xb7u8, 0xfbu8, 0x75u8, 0xbau8, 0xdbu8, 0xc1u8, 0x54u8, 0x7au8, 0x1cu8, 0xd9u8, 0xeeu8, 0x56u8, 0x0cu8, 0x15u8, 0x06u8, 0x7fu8, 0xbdu8, 0x98u8, 0x5cu8, 0x6cu8, 0xeau8]) }
+  fn int_neg_addr() -> Addr { store([0x67u8, 0x01u8, 0xd7u8, 0x65u8, 0xffu8, 0x10u8, 0xbfu8, 0xa3u8, 0xa6u8, 0xc3u8, 0x47u8, 0xdfu8, 0x15u8, 0x19u8, 0x4eu8, 0x0du8, 0xb8u8, 0x62u8, 0xeeu8, 0x25u8, 0xb5u8, 0x4fu8, 0x25u8, 0xa5u8, 0x9fu8, 0x7cu8, 0xf2u8, 0x19u8, 0x51u8, 0xa3u8, 0x99u8, 0x7eu8]) }
+  fn int_emod_addr() -> Addr { store([0xe2u8, 0x9cu8, 0xfau8, 0x79u8, 0x21u8, 0xbbu8, 0x57u8, 0xf4u8, 0x78u8, 0x2bu8, 0x02u8, 0x1cu8, 0x97u8, 0x75u8, 0x96u8, 0xa4u8, 0xfau8, 0xe0u8, 0x4eu8, 0x94u8, 0xf7u8, 0xb0u8, 0x79u8, 0x55u8, 0xfeu8, 0x28u8, 0x14u8, 0xfcu8, 0x48u8, 0xdeu8, 0x90u8, 0xe7u8]) }
+  fn int_ediv_addr() -> Addr { store([0x9cu8, 0x95u8, 0x2du8, 0x45u8, 0xa3u8, 0xbdu8, 0x43u8, 0x16u8, 0x15u8, 0x29u8, 0xfcu8, 0xfbu8, 0x5eu8, 0x27u8, 0x6bu8, 0xeau8, 0xb0u8, 0xcfu8, 0x4fu8, 0xd6u8, 0x4au8, 0x01u8, 0xbau8, 0x9bu8, 0xc2u8, 0xc7u8, 0xcdu8, 0xa3u8, 0x76u8, 0xcbu8, 0x8fu8, 0x54u8]) }
+  fn int_bmod_addr() -> Addr { store([0x0bu8, 0x15u8, 0x64u8, 0xdeu8, 0xa6u8, 0xffu8, 0xcdu8, 0x20u8, 0x4eu8, 0xbcu8, 0xd1u8, 0xaau8, 0x69u8, 0xd2u8, 0x9eu8, 0xe6u8, 0xf3u8, 0xacu8, 0xccu8, 0xd8u8, 0x7bu8, 0xd1u8, 0x46u8, 0xffu8, 0x67u8, 0x45u8, 0x56u8, 0xacu8, 0x9cu8, 0xc8u8, 0xccu8, 0xb3u8]) }
+  fn int_bdiv_addr() -> Addr { store([0x6du8, 0x35u8, 0xdcu8, 0x43u8, 0x66u8, 0x0fu8, 0x6cu8, 0x50u8, 0x9au8, 0x13u8, 0xf2u8, 0x82u8, 0x4cu8, 0x02u8, 0x7eu8, 0xd9u8, 0x9au8, 0xb0u8, 0x70u8, 0xa0u8, 0x8fu8, 0x05u8, 0x8fu8, 0xf0u8, 0xa5u8, 0xf4u8, 0x6au8, 0x75u8, 0x92u8, 0x50u8, 0x79u8, 0x7du8]) }
+  fn int_nat_abs_addr() -> Addr { store([0x26u8, 0x1au8, 0xe5u8, 0x4eu8, 0xdbu8, 0x66u8, 0xe9u8, 0x00u8, 0x78u8, 0x4au8, 0x64u8, 0x35u8, 0x0bu8, 0xc0u8, 0x1eu8, 0x8bu8, 0x3fu8, 0xe1u8, 0x33u8, 0x2au8, 0x47u8, 0xcau8, 0xeau8, 0xb5u8, 0x8eu8, 0x03u8, 0x61u8, 0xdfu8, 0xfcu8, 0x7eu8, 0xa0u8, 0x08u8]) }
+  fn int_pow_addr() -> Addr { store([0x87u8, 0x26u8, 0x64u8, 0x15u8, 0x98u8, 0x2bu8, 0xbdu8, 0xecu8, 0x50u8, 0xc6u8, 0x1du8, 0xecu8, 0x5bu8, 0x73u8, 0xccu8, 0x0cu8, 0xcdu8, 0x5cu8, 0x99u8, 0x74u8, 0x45u8, 0x99u8, 0x7au8, 0x97u8, 0x24u8, 0xa1u8, 0xccu8, 0x5cu8, 0x2eu8, 0x39u8, 0xd3u8, 0xa4u8]) }
 
 
   fn nat_add_addr() -> Addr {
-    store([0xf9u8, 0xacu8, 0x92u8, 0xa1u8, 0x13u8, 0x88u8, 0xa7u8, 0xcdu8,
-     0xcau8, 0x22u8, 0x9au8, 0x80u8, 0x24u8, 0x20u8, 0x85u8, 0x54u8,
-     0xfeu8, 0xb3u8, 0x2du8, 0x6cu8, 0x0au8, 0x3au8, 0xf7u8, 0x4au8,
-     0x7bu8, 0xc1u8, 0x2cu8, 0x28u8, 0xb9u8, 0x49u8, 0x54u8, 0x3cu8])
+    store([0x72u8, 0x4du8, 0xb7u8, 0x97u8, 0xe1u8, 0x81u8, 0x75u8, 0x45u8,
+     0xa0u8, 0x83u8, 0x71u8, 0x43u8, 0x2fu8, 0xd1u8, 0xfau8, 0x64u8,
+     0x28u8, 0xa3u8, 0x7du8, 0xcfu8, 0x9cu8, 0x16u8, 0x71u8, 0xdfu8,
+     0x7eu8, 0x46u8, 0x48u8, 0x49u8, 0xdbu8, 0x0au8, 0x81u8, 0xacu8])
   }
 
   fn nat_sub_addr() -> Addr {
-    store([0xdfu8, 0x38u8, 0x35u8, 0x2fu8, 0xfau8, 0x1du8, 0x6eu8, 0x29u8,
-     0x23u8, 0x49u8, 0x25u8, 0x9fu8, 0x33u8, 0xebu8, 0x67u8, 0x80u8,
-     0x24u8, 0xbbu8, 0x64u8, 0x6bu8, 0x35u8, 0x86u8, 0x38u8, 0xa0u8,
-     0x2du8, 0xa1u8, 0x99u8, 0x5eu8, 0xd4u8, 0xabu8, 0xebu8, 0x09u8])
+    store([0x9du8, 0xe2u8, 0xd2u8, 0xc6u8, 0x0eu8, 0x7du8, 0x42u8, 0x1au8,
+     0x2fu8, 0xdfu8, 0xb8u8, 0x70u8, 0x6eu8, 0x91u8, 0xe0u8, 0xe6u8,
+     0xd8u8, 0x57u8, 0x6cu8, 0x3bu8, 0xd4u8, 0x6eu8, 0xc0u8, 0x04u8,
+     0x05u8, 0xc6u8, 0x58u8, 0x75u8, 0xcbu8, 0x9bu8, 0x5au8, 0x26u8])
   }
 
   fn nat_mul_addr() -> Addr {
-    store([0xf3u8, 0x8du8, 0x4fu8, 0x7bu8, 0xaau8, 0xa0u8, 0x21u8, 0xe3u8,
-     0xb5u8, 0x55u8, 0x31u8, 0x21u8, 0x45u8, 0xd9u8, 0xffu8, 0xd3u8,
-     0xddu8, 0xc5u8, 0xeau8, 0xcbu8, 0x7bu8, 0xfdu8, 0x5bu8, 0x86u8,
-     0xa7u8, 0xb0u8, 0xeau8, 0xfdu8, 0xfcu8, 0xf4u8, 0x16u8, 0xaau8])
+    store([0x56u8, 0x6au8, 0x3cu8, 0x22u8, 0x49u8, 0xbcu8, 0x20u8, 0x76u8,
+     0x54u8, 0x3du8, 0x9bu8, 0xc5u8, 0x61u8, 0xa8u8, 0x41u8, 0xf6u8,
+     0xfdu8, 0x35u8, 0xffu8, 0xb5u8, 0xbdu8, 0xbbu8, 0xc5u8, 0xc9u8,
+     0x91u8, 0xa9u8, 0xc6u8, 0x4fu8, 0xecu8, 0xcbu8, 0xd5u8, 0xd4u8])
   }
 
   fn nat_pow_addr() -> Addr {
-    store([0x68u8, 0xf6u8, 0x1eu8, 0xf5u8, 0x5bu8, 0x63u8, 0xcdu8, 0x23u8,
-     0xadu8, 0x8eu8, 0xd1u8, 0x85u8, 0xb7u8, 0xeeu8, 0xc3u8, 0xdcu8,
-     0x75u8, 0x4eu8, 0x61u8, 0xccu8, 0x58u8, 0x05u8, 0x60u8, 0x87u8,
-     0xa9u8, 0x7eu8, 0x81u8, 0x9du8, 0x0eu8, 0x95u8, 0xe6u8, 0xfdu8])
+    store([0x5bu8, 0xa4u8, 0x3au8, 0xc3u8, 0xe5u8, 0xd2u8, 0x9fu8, 0xe5u8,
+     0xceu8, 0x81u8, 0xf1u8, 0x8au8, 0x18u8, 0x17u8, 0x8au8, 0x27u8,
+     0x05u8, 0xc3u8, 0x7eu8, 0xe6u8, 0x74u8, 0xb9u8, 0xb6u8, 0xeeu8,
+     0x50u8, 0xe9u8, 0x46u8, 0x6au8, 0x86u8, 0x59u8, 0x3bu8, 0x15u8])
   }
 
   fn nat_gcd_addr() -> Addr {
-    store([0xadu8, 0x47u8, 0xf2u8, 0xbbu8, 0xe8u8, 0x91u8, 0xb8u8, 0x25u8,
-     0xc4u8, 0x8au8, 0x27u8, 0x8fu8, 0x9au8, 0x0du8, 0x72u8, 0x99u8,
-     0x7bu8, 0x78u8, 0xbau8, 0xacu8, 0x79u8, 0x89u8, 0x1cu8, 0xa6u8,
-     0x65u8, 0x19u8, 0x88u8, 0xb7u8, 0xc9u8, 0xb4u8, 0x7fu8, 0x03u8])
+    store([0x76u8, 0x00u8, 0x7du8, 0xcfu8, 0x8bu8, 0x28u8, 0x5cu8, 0xdbu8,
+     0xd6u8, 0xf7u8, 0x79u8, 0x01u8, 0x22u8, 0x90u8, 0xfeu8, 0x2eu8,
+     0x6au8, 0xfdu8, 0x22u8, 0x1cu8, 0xe8u8, 0x82u8, 0x10u8, 0x82u8,
+     0xa7u8, 0xe2u8, 0xefu8, 0x81u8, 0xe8u8, 0xd8u8, 0x15u8, 0xcfu8])
   }
 
   fn nat_mod_addr() -> Addr {
-    store([0xf6u8, 0xebu8, 0x74u8, 0x29u8, 0x96u8, 0xc6u8, 0x0fu8, 0x10u8,
-     0x68u8, 0xc2u8, 0xd4u8, 0x37u8, 0xafu8, 0xddu8, 0x8bu8, 0x36u8,
-     0x09u8, 0x04u8, 0x0du8, 0x64u8, 0xeeu8, 0xc5u8, 0xe1u8, 0x5fu8,
-     0x07u8, 0xa1u8, 0x1du8, 0xc1u8, 0x1du8, 0x07u8, 0x0du8, 0x7bu8])
+    store([0xe6u8, 0xffu8, 0xe7u8, 0x87u8, 0x13u8, 0xd4u8, 0xb9u8, 0x74u8,
+     0xa8u8, 0x2du8, 0x01u8, 0x87u8, 0x53u8, 0x8fu8, 0x1au8, 0x0cu8,
+     0xf5u8, 0xc4u8, 0xb2u8, 0x60u8, 0xf0u8, 0xfdu8, 0x99u8, 0x26u8,
+     0x4fu8, 0xabu8, 0x26u8, 0x3bu8, 0x1au8, 0xf8u8, 0x47u8, 0xf9u8])
   }
 
   fn nat_div_addr() -> Addr {
-    store([0x23u8, 0x17u8, 0x36u8, 0x49u8, 0xa5u8, 0x8eu8, 0xa5u8, 0x09u8,
-     0x5du8, 0x1cu8, 0x51u8, 0xa2u8, 0x1cu8, 0x7au8, 0xd2u8, 0xcfu8,
-     0x8eu8, 0x8du8, 0xccu8, 0xefu8, 0x34u8, 0x26u8, 0x98u8, 0xe0u8,
-     0x7eu8, 0x24u8, 0x16u8, 0x68u8, 0xffu8, 0x7au8, 0xd3u8, 0xe7u8])
+    store([0xc0u8, 0x75u8, 0xedu8, 0x97u8, 0x6fu8, 0x17u8, 0x02u8, 0xf3u8,
+     0x64u8, 0xfbu8, 0x0bu8, 0xb3u8, 0x4au8, 0xa8u8, 0xbbu8, 0xc1u8,
+     0x66u8, 0xadu8, 0xacu8, 0xe5u8, 0x73u8, 0xf2u8, 0xceu8, 0x91u8,
+     0x4bu8, 0x43u8, 0xdcu8, 0x4fu8, 0x4au8, 0xabu8, 0x62u8, 0x19u8])
   }
 
   fn nat_land_addr() -> Addr {
-    store([0x8fu8, 0x47u8, 0x5cu8, 0xc7u8, 0x2du8, 0xa2u8, 0xacu8, 0x6cu8,
-     0xe2u8, 0xa9u8, 0x28u8, 0x2bu8, 0x6bu8, 0x5du8, 0xf4u8, 0xccu8,
-     0xf7u8, 0xbcu8, 0x3cu8, 0xeeu8, 0x06u8, 0x49u8, 0xd2u8, 0x27u8,
-     0x66u8, 0xbeu8, 0xbdu8, 0x32u8, 0xd1u8, 0x80u8, 0x6fu8, 0x3bu8])
+    store([0xc6u8, 0x1fu8, 0xadu8, 0x46u8, 0xa1u8, 0x02u8, 0xdbu8, 0xffu8,
+     0x59u8, 0x22u8, 0x31u8, 0x2du8, 0x4fu8, 0xbeu8, 0x6eu8, 0x70u8,
+     0x4eu8, 0xc3u8, 0xc6u8, 0x2cu8, 0x6cu8, 0x6fu8, 0x64u8, 0xb3u8,
+     0xd4u8, 0x81u8, 0xb7u8, 0x8cu8, 0x77u8, 0xcfu8, 0x31u8, 0x5du8])
   }
 
   fn nat_lor_addr() -> Addr {
-    store([0x8fu8, 0x3cu8, 0x1cu8, 0x43u8, 0x2cu8, 0x59u8, 0x8eu8, 0x42u8,
-     0x40u8, 0xd3u8, 0x6fu8, 0x89u8, 0x45u8, 0x94u8, 0x21u8, 0x74u8,
-     0x67u8, 0x5cu8, 0x5cu8, 0x91u8, 0xe0u8, 0x3fu8, 0x6bu8, 0x8au8,
-     0xb0u8, 0x18u8, 0xe8u8, 0xb0u8, 0x52u8, 0x62u8, 0x2cu8, 0x63u8])
+    store([0xcbu8, 0x7du8, 0xccu8, 0xc0u8, 0x20u8, 0xa5u8, 0x30u8, 0xfeu8,
+     0xd7u8, 0xc6u8, 0x22u8, 0xb1u8, 0x00u8, 0xeeu8, 0x52u8, 0xc1u8,
+     0x07u8, 0x8bu8, 0x50u8, 0x18u8, 0x15u8, 0x9bu8, 0xa4u8, 0x68u8,
+     0x2fu8, 0x81u8, 0x7eu8, 0x37u8, 0x76u8, 0x78u8, 0x9eu8, 0xe8u8])
   }
 
   fn nat_xor_addr() -> Addr {
-    store([0x80u8, 0x0au8, 0x8au8, 0x2du8, 0x6fu8, 0x91u8, 0xbdu8, 0x1au8,
-     0x91u8, 0xd3u8, 0x13u8, 0xd1u8, 0xe1u8, 0x9eu8, 0xf6u8, 0x9fu8,
-     0x37u8, 0xdeu8, 0xddu8, 0x07u8, 0xf7u8, 0xdeu8, 0x4fu8, 0x92u8,
-     0x97u8, 0x80u8, 0xbeu8, 0x85u8, 0x5au8, 0x03u8, 0xfdu8, 0x1fu8])
+    store([0xd8u8, 0xa6u8, 0xb0u8, 0x5au8, 0x1au8, 0x4eu8, 0x5cu8, 0xadu8,
+     0xc6u8, 0x9cu8, 0x53u8, 0x79u8, 0x2eu8, 0x8eu8, 0x13u8, 0x03u8,
+     0x14u8, 0x74u8, 0x5eu8, 0x76u8, 0xe3u8, 0x2bu8, 0xb3u8, 0x0au8,
+     0x9cu8, 0xe0u8, 0x27u8, 0x2fu8, 0xa0u8, 0x79u8, 0xe8u8, 0xa6u8])
   }
 
   fn nat_shift_left_addr() -> Addr {
-    store([0x54u8, 0x73u8, 0x59u8, 0x2eu8, 0x70u8, 0x79u8, 0x43u8, 0xecu8,
-     0x07u8, 0x2au8, 0x2eu8, 0xe5u8, 0x3cu8, 0x43u8, 0x3du8, 0xa2u8,
-     0xc7u8, 0x7au8, 0xa4u8, 0x5eu8, 0xd6u8, 0x34u8, 0xdau8, 0x54u8,
-     0xb2u8, 0x43u8, 0x74u8, 0xd1u8, 0x9eu8, 0xb9u8, 0x0cu8, 0xd2u8])
+    store([0x5cu8, 0x15u8, 0xf9u8, 0x8eu8, 0x2bu8, 0xd9u8, 0xc2u8, 0x57u8,
+     0xbcu8, 0xdfu8, 0xacu8, 0x62u8, 0xb0u8, 0x04u8, 0x3au8, 0x2eu8,
+     0x3eu8, 0x2bu8, 0xbdu8, 0xffu8, 0x8bu8, 0x21u8, 0x0fu8, 0x10u8,
+     0x4bu8, 0x5cu8, 0x37u8, 0x39u8, 0xe8u8, 0x62u8, 0xacu8, 0x0cu8])
   }
 
   fn nat_shift_right_addr() -> Addr {
-    store([0x1bu8, 0x59u8, 0x11u8, 0x49u8, 0x15u8, 0x8du8, 0x89u8, 0x69u8,
-     0x37u8, 0xeeu8, 0xbfu8, 0xd5u8, 0x32u8, 0x32u8, 0xb5u8, 0xaeu8,
-     0x8au8, 0x4bu8, 0xcdu8, 0xb2u8, 0x5au8, 0x68u8, 0x11u8, 0xc9u8,
-     0x6bu8, 0xd9u8, 0x41u8, 0x14u8, 0xa9u8, 0xf8u8, 0xbeu8, 0xd5u8])
+    store([0x3fu8, 0x92u8, 0x72u8, 0x53u8, 0x24u8, 0xb0u8, 0x9fu8, 0xa7u8,
+     0x5cu8, 0x6fu8, 0xcdu8, 0x16u8, 0xdau8, 0x86u8, 0x36u8, 0x71u8,
+     0x42u8, 0x8fu8, 0xf3u8, 0x3bu8, 0x7du8, 0xb6u8, 0x67u8, 0xebu8,
+     0x76u8, 0x0eu8, 0x1cu8, 0xd5u8, 0x03u8, 0xa2u8, 0xbcu8, 0xadu8])
   }
 
   fn nat_beq_addr() -> Addr {
-    store([0x72u8, 0xc6u8, 0xd4u8, 0xa3u8, 0xb6u8, 0x53u8, 0x79u8, 0x88u8,
-     0x50u8, 0xa9u8, 0xedu8, 0x57u8, 0x01u8, 0x8bu8, 0x87u8, 0xceu8,
-     0xeeu8, 0x0eu8, 0x34u8, 0x19u8, 0x5cu8, 0x09u8, 0x02u8, 0x85u8,
-     0x8fu8, 0xd4u8, 0x1fu8, 0x6fu8, 0x0eu8, 0x99u8, 0x62u8, 0xaeu8])
+    store([0xffu8, 0xd3u8, 0xf0u8, 0x2au8, 0x19u8, 0xfdu8, 0xa6u8, 0x49u8,
+     0xaau8, 0x56u8, 0x08u8, 0xedu8, 0x81u8, 0x8du8, 0xb3u8, 0x82u8,
+     0xe1u8, 0x60u8, 0x23u8, 0x1bu8, 0x76u8, 0xd5u8, 0xb0u8, 0x91u8,
+     0x76u8, 0xd7u8, 0xddu8, 0x1au8, 0x8du8, 0x5bu8, 0x1eu8, 0xc5u8])
   }
 
   fn nat_ble_addr() -> Addr {
-    store([0xc3u8, 0x7fu8, 0x2eu8, 0x81u8, 0x1fu8, 0x44u8, 0xd5u8, 0x9cu8,
-     0x07u8, 0x09u8, 0x49u8, 0x47u8, 0x14u8, 0x6fu8, 0xfcu8, 0xbdu8,
-     0x3au8, 0xecu8, 0x5eu8, 0xc7u8, 0x00u8, 0x2au8, 0xc3u8, 0xc4u8,
-     0x8eu8, 0xbdu8, 0xebu8, 0xcdu8, 0x83u8, 0xd4u8, 0x68u8, 0x8eu8])
+    store([0x68u8, 0xa3u8, 0x64u8, 0x3eu8, 0xc6u8, 0x98u8, 0x16u8, 0xaeu8,
+     0xc1u8, 0x07u8, 0x30u8, 0x2du8, 0xdbu8, 0xfau8, 0x05u8, 0x4cu8,
+     0xebu8, 0xcdu8, 0x3eu8, 0xc1u8, 0x73u8, 0xcdu8, 0x5fu8, 0x7eu8,
+     0x6du8, 0x88u8, 0x36u8, 0x38u8, 0x63u8, 0x1au8, 0xfeu8, 0x65u8])
   }
 
   fn bool_true_addr() -> Addr {
@@ -187,46 +187,46 @@ def natPrim := ⟦
 
   -- Native primitives ()
   fn system_platform_num_bits_addr() -> Addr {
-    store([0x50u8, 0x60u8, 0xa2u8, 0x2du8, 0xf8u8, 0x63u8, 0x07u8, 0xddu8,
-     0x8bu8, 0xbeu8, 0x65u8, 0x6eu8, 0x13u8, 0x86u8, 0x8fu8, 0x3au8,
-     0x16u8, 0x18u8, 0xe7u8, 0xa0u8, 0xd8u8, 0x80u8, 0xb8u8, 0xcbu8,
-     0xb0u8, 0x07u8, 0x59u8, 0xcfu8, 0xfdu8, 0x31u8, 0x80u8, 0x0du8])
+    store([0x6fu8, 0x62u8, 0x06u8, 0x54u8, 0xd3u8, 0x41u8, 0x99u8, 0x0au8,
+     0x30u8, 0x13u8, 0x87u8, 0xb8u8, 0x0eu8, 0xf7u8, 0x5bu8, 0x1eu8,
+     0x0bu8, 0x61u8, 0x30u8, 0xddu8, 0xf1u8, 0x91u8, 0x64u8, 0x02u8,
+     0x5bu8, 0x6du8, 0xc3u8, 0x7bu8, 0xf3u8, 0xc3u8, 0xdcu8, 0x18u8])
   }
 
   fn punit_size_of_1_addr() -> Addr {
-    store([0x84u8, 0xfeu8, 0x3du8, 0x0fu8, 0x08u8, 0xf0u8, 0x65u8, 0x1au8,
-     0x6fu8, 0x09u8, 0x36u8, 0xa9u8, 0xa0u8, 0xf1u8, 0x8eu8, 0x4fu8,
-     0x0du8, 0xacu8, 0xe1u8, 0x69u8, 0xacu8, 0x42u8, 0x33u8, 0xbfu8,
-     0x1au8, 0xdau8, 0xd0u8, 0x5du8, 0x6eu8, 0x07u8, 0x8au8, 0x25u8])
+    store([0xe8u8, 0x5bu8, 0xf5u8, 0x16u8, 0xc7u8, 0x6cu8, 0xadu8, 0xd8u8,
+     0xceu8, 0x1fu8, 0xdau8, 0xb3u8, 0xccu8, 0x94u8, 0xedu8, 0x68u8,
+     0x5eu8, 0x47u8, 0xbeu8, 0x3cu8, 0x7au8, 0x8bu8, 0x52u8, 0xf5u8,
+     0x3fu8, 0xe2u8, 0xb3u8, 0x50u8, 0x2eu8, 0x6fu8, 0x70u8, 0xc7u8])
   }
 
   -- Compiler-emitted native reduction primitives.
   fn reduce_bool_addr() -> Addr {
-    store([0xd4u8, 0xd7u8, 0x75u8, 0xceu8, 0xffu8, 0x37u8, 0xabu8, 0x7au8,
-     0x40u8, 0x24u8, 0x16u8, 0x11u8, 0x8fu8, 0x1du8, 0x2cu8, 0xe5u8,
-     0xb9u8, 0xe7u8, 0xf2u8, 0x14u8, 0x3du8, 0x0cu8, 0x3du8, 0xc8u8,
-     0xfeu8, 0x54u8, 0x31u8, 0x57u8, 0x1du8, 0xf3u8, 0x26u8, 0x0cu8])
+    store([0xbau8, 0xccu8, 0x4cu8, 0x81u8, 0x4au8, 0x45u8, 0x72u8, 0xddu8,
+     0xfdu8, 0x96u8, 0x9au8, 0x18u8, 0x57u8, 0xadu8, 0xfeu8, 0x18u8,
+     0x23u8, 0x9eu8, 0xb6u8, 0xbdu8, 0x8bu8, 0x16u8, 0x27u8, 0xeeu8,
+     0x79u8, 0x74u8, 0x4au8, 0x6au8, 0x9bu8, 0x23u8, 0xb0u8, 0x30u8])
   }
 
   fn reduce_nat_addr() -> Addr {
-    store([0x20u8, 0x75u8, 0xbdu8, 0xa5u8, 0x45u8, 0x7bu8, 0x29u8, 0x9bu8,
-     0x27u8, 0x24u8, 0x67u8, 0x70u8, 0xc8u8, 0x41u8, 0x62u8, 0x73u8,
-     0x68u8, 0x6bu8, 0xbfu8, 0x62u8, 0x7au8, 0xa6u8, 0xa0u8, 0x1au8,
-     0xc4u8, 0x13u8, 0xa2u8, 0x7eu8, 0x58u8, 0x3eu8, 0xb9u8, 0x5du8])
+    store([0xb6u8, 0x32u8, 0x7du8, 0x9au8, 0x1bu8, 0xbbu8, 0x46u8, 0x1au8,
+     0x44u8, 0x7fu8, 0x0cu8, 0x97u8, 0x1eu8, 0x62u8, 0x2du8, 0xd9u8,
+     0xa3u8, 0x51u8, 0x32u8, 0xbdu8, 0x7du8, 0xe7u8, 0x5bu8, 0xf6u8,
+     0x9eu8, 0x20u8, 0x79u8, 0x4du8, 0x7au8, 0x0eu8, 0x85u8, 0x95u8])
   }
 
   fn subtype_val_addr() -> Addr {
-    store([0x7eu8, 0x4eu8, 0x9bu8, 0x33u8, 0xb6u8, 0x96u8, 0xa7u8, 0xd3u8,
-     0xfcu8, 0xe1u8, 0x74u8, 0x5du8, 0xfbu8, 0x5fu8, 0xbeu8, 0xebu8,
-     0x93u8, 0x8fu8, 0xc8u8, 0x88u8, 0x2au8, 0x82u8, 0xbeu8, 0xe1u8,
-     0x57u8, 0x23u8, 0xe0u8, 0xd2u8, 0x53u8, 0xe5u8, 0x91u8, 0x58u8])
+    store([0xeau8, 0x65u8, 0xf5u8, 0x17u8, 0x45u8, 0x7fu8, 0xaeu8, 0x9bu8,
+     0x70u8, 0x52u8, 0x99u8, 0xdau8, 0x08u8, 0xb0u8, 0xd3u8, 0xc8u8,
+     0xcfu8, 0x9au8, 0x47u8, 0x6fu8, 0x16u8, 0x47u8, 0x0cu8, 0xcau8,
+     0x5cu8, 0xaeu8, 0x5eu8, 0xa7u8, 0xbdu8, 0x23u8, 0x82u8, 0x30u8])
   }
 
   fn system_platform_get_num_bits_addr() -> Addr {
-    store([0x80u8, 0xf9u8, 0x75u8, 0xdeu8, 0xd9u8, 0xd6u8, 0xabu8, 0x70u8,
-     0x95u8, 0xe9u8, 0xdbu8, 0x2eu8, 0xd1u8, 0xcfu8, 0xa6u8, 0xf5u8,
-     0xc3u8, 0x5eu8, 0xafu8, 0xe5u8, 0xc5u8, 0x69u8, 0x90u8, 0xe2u8,
-     0xc1u8, 0x32u8, 0x1bu8, 0x02u8, 0xc5u8, 0x66u8, 0x4eu8, 0x6cu8])
+    store([0x00u8, 0xc2u8, 0x66u8, 0x83u8, 0x4fu8, 0x90u8, 0x39u8, 0x93u8,
+     0x1bu8, 0x4bu8, 0xe2u8, 0xfau8, 0xc5u8, 0x58u8, 0x4cu8, 0xd1u8,
+     0x76u8, 0xa0u8, 0xaeu8, 0x7eu8, 0xe4u8, 0xcbu8, 0x40u8, 0x64u8,
+     0xddu8, 0xb5u8, 0xe0u8, 0x4du8, 0xd1u8, 0x2bu8, 0x6cu8, 0xbbu8])
   }
 
 
@@ -348,45 +348,45 @@ def natPrim := ⟦
 
   -- BitVec primitives ()
   fn bit_vec_to_nat_addr() -> Addr {
-    store([0xacu8, 0xd9u8, 0xf0u8, 0xa3u8, 0xf7u8, 0xe8u8, 0xc5u8, 0x3au8,
-     0x46u8, 0xb9u8, 0x17u8, 0x59u8, 0x35u8, 0x83u8, 0x66u8, 0xfau8,
-     0x02u8, 0x82u8, 0x40u8, 0xb0u8, 0xb6u8, 0xccu8, 0x09u8, 0x20u8,
-     0x5du8, 0xdeu8, 0x34u8, 0xa3u8, 0x35u8, 0x44u8, 0x67u8, 0x8du8])
+    store([0xc1u8, 0x10u8, 0xd6u8, 0x14u8, 0xb4u8, 0x41u8, 0xc6u8, 0xccu8,
+     0xa6u8, 0x9eu8, 0xcdu8, 0x7cu8, 0x1cu8, 0x2cu8, 0x76u8, 0xf3u8,
+     0xbcu8, 0x21u8, 0xfdu8, 0x40u8, 0xc4u8, 0x00u8, 0x1eu8, 0x6au8,
+     0x1au8, 0x7du8, 0x1cu8, 0xf4u8, 0x81u8, 0xe2u8, 0x3cu8, 0xddu8])
   }
 
   fn bit_vec_of_nat_addr() -> Addr {
-    store([0x57u8, 0x21u8, 0xcau8, 0x2au8, 0xcfu8, 0x2cu8, 0x69u8, 0x94u8,
-     0x77u8, 0x15u8, 0x09u8, 0x33u8, 0x2fu8, 0xb1u8, 0x85u8, 0xf7u8,
-     0x83u8, 0xf4u8, 0x42u8, 0xaeu8, 0xfcu8, 0xe4u8, 0x17u8, 0xd2u8,
-     0x86u8, 0x3eu8, 0x2du8, 0x14u8, 0x8eu8, 0xdcu8, 0xdbu8, 0x8au8])
+    store([0x29u8, 0xb9u8, 0xf2u8, 0x40u8, 0x86u8, 0xb1u8, 0xb1u8, 0xf8u8,
+     0x82u8, 0x11u8, 0x35u8, 0x88u8, 0x66u8, 0x13u8, 0x9fu8, 0xdbu8,
+     0x7du8, 0xcdu8, 0xfcu8, 0x97u8, 0xb5u8, 0xf6u8, 0xc7u8, 0x7fu8,
+     0xc4u8, 0x95u8, 0xbfu8, 0x8cu8, 0x77u8, 0x63u8, 0x99u8, 0x82u8])
   }
 
   fn bit_vec_addr() -> Addr {
-    store([0xc7u8, 0x19u8, 0x2au8, 0xc5u8, 0x07u8, 0xd6u8, 0x7cu8, 0x3cu8,
-     0x3eu8, 0x1eu8, 0xb9u8, 0x06u8, 0x33u8, 0x85u8, 0x8au8, 0xe7u8,
-     0xb7u8, 0xcbu8, 0xc8u8, 0x0eu8, 0x39u8, 0x88u8, 0x31u8, 0x26u8,
-     0x18u8, 0xc7u8, 0xecu8, 0x09u8, 0xb4u8, 0x83u8, 0xb0u8, 0x4au8])
+    store([0x7fu8, 0x0fu8, 0x5fu8, 0xedu8, 0xa1u8, 0x82u8, 0x80u8, 0x72u8,
+     0x12u8, 0x3fu8, 0x24u8, 0x2au8, 0x46u8, 0xa4u8, 0x05u8, 0x49u8,
+     0xe8u8, 0x59u8, 0x34u8, 0xf7u8, 0x39u8, 0x5eu8, 0x4fu8, 0x93u8,
+     0xf6u8, 0x5du8, 0xdau8, 0x4eu8, 0x48u8, 0x09u8, 0xf3u8, 0x25u8])
   }
 
   fn bit_vec_ult_addr() -> Addr {
-    store([0x8du8, 0x57u8, 0xc7u8, 0xc6u8, 0xaeu8, 0xe1u8, 0xbau8, 0x51u8,
-     0x0du8, 0x32u8, 0x08u8, 0xddu8, 0xc4u8, 0xb0u8, 0x8au8, 0x83u8,
-     0xb4u8, 0x43u8, 0x19u8, 0xf6u8, 0xafu8, 0x8eu8, 0xe0u8, 0x9bu8,
-     0x39u8, 0x40u8, 0xd0u8, 0xddu8, 0xedu8, 0xceu8, 0x1eu8, 0xb6u8])
+    store([0x93u8, 0x01u8, 0xd8u8, 0x50u8, 0xbdu8, 0xe2u8, 0x46u8, 0x94u8,
+     0x0bu8, 0x7bu8, 0x3eu8, 0x81u8, 0xe7u8, 0x86u8, 0xf7u8, 0xf1u8,
+     0x2bu8, 0xaeu8, 0x8eu8, 0x5cu8, 0xeau8, 0x6bu8, 0x3fu8, 0x40u8,
+     0x40u8, 0x06u8, 0x0bu8, 0x3au8, 0x7fu8, 0x59u8, 0x55u8, 0x7cu8])
   }
 
   fn decidable_decide_addr() -> Addr {
-    store([0xd1u8, 0x10u8, 0x7cu8, 0x99u8, 0xadu8, 0x9eu8, 0xbcu8, 0xb5u8,
-     0x02u8, 0x8du8, 0x9au8, 0xeau8, 0x0du8, 0xa5u8, 0x21u8, 0xedu8,
-     0x5cu8, 0x12u8, 0xe7u8, 0x1eu8, 0xa2u8, 0xecu8, 0xdeu8, 0xafu8,
-     0x63u8, 0x7bu8, 0xb4u8, 0xa1u8, 0x4du8, 0x4au8, 0x7eu8, 0x44u8])
+    store([0x20u8, 0xe8u8, 0x90u8, 0x62u8, 0x80u8, 0xb4u8, 0xdcu8, 0xd7u8,
+     0x4au8, 0x7au8, 0x78u8, 0xe0u8, 0x6du8, 0x58u8, 0x0eu8, 0x6fu8,
+     0x00u8, 0xeeu8, 0xbbu8, 0xa9u8, 0xfcu8, 0x40u8, 0x78u8, 0x92u8,
+     0x62u8, 0xe9u8, 0x5cu8, 0xacu8, 0xb6u8, 0xf0u8, 0xd6u8, 0x99u8])
   }
 
   fn lt_lt_addr() -> Addr {
-    store([0xc6u8, 0x9du8, 0xf4u8, 0x83u8, 0x3eu8, 0xcdu8, 0xceu8, 0x76u8,
-     0xbdu8, 0xb0u8, 0xd2u8, 0x31u8, 0x59u8, 0xe1u8, 0xfau8, 0xc6u8,
-     0x52u8, 0xd8u8, 0x89u8, 0x19u8, 0x76u8, 0x8cu8, 0x31u8, 0x2cu8,
-     0x66u8, 0x11u8, 0xdcu8, 0x06u8, 0x0du8, 0xa1u8, 0x6fu8, 0x04u8])
+    store([0x48u8, 0x02u8, 0xb1u8, 0x83u8, 0xf4u8, 0xd6u8, 0xdcu8, 0xccu8,
+     0xacu8, 0xbau8, 0x57u8, 0x72u8, 0x18u8, 0x24u8, 0xa7u8, 0xbbu8,
+     0x67u8, 0xdau8, 0xebu8, 0x27u8, 0x25u8, 0xdau8, 0x17u8, 0x23u8,
+     0x92u8, 0x71u8, 0xc1u8, 0x35u8, 0x95u8, 0x2cu8, 0xaau8, 0x61u8])
   }
 
   fn is_bitvec_prim_addr(a: Addr) -> G {
@@ -592,10 +592,10 @@ def natPrim := ⟦
 
   -- String primitives ()
   fn string_utf8_byte_size_addr() -> Addr {
-    store([0xb1u8, 0xf6u8, 0xf0u8, 0x4bu8, 0xdeu8, 0x3du8, 0x81u8, 0xf9u8,
-     0x10u8, 0x2eu8, 0xa6u8, 0xb7u8, 0xd2u8, 0xc9u8, 0xf4u8, 0x23u8,
-     0x6du8, 0x72u8, 0xb1u8, 0x7eu8, 0x01u8, 0x12u8, 0x55u8, 0x23u8,
-     0xc5u8, 0xd5u8, 0xe2u8, 0x61u8, 0xafu8, 0xc7u8, 0x11u8, 0x05u8])
+    store([0x52u8, 0xb0u8, 0x22u8, 0x6eu8, 0xa1u8, 0x4cu8, 0x94u8, 0xb1u8,
+     0xf9u8, 0x33u8, 0x4cu8, 0x99u8, 0x57u8, 0xf5u8, 0x58u8, 0x93u8,
+     0x99u8, 0xa8u8, 0x6bu8, 0xcdu8, 0xaeu8, 0x11u8, 0x1fu8, 0x28u8,
+     0x47u8, 0xc9u8, 0xb0u8, 0xc2u8, 0xfbu8, 0x0au8, 0x22u8, 0x61u8])
   }
 
   -- Native string-value fast paths (mirror crates/kernel/src/primitive.rs
@@ -603,87 +603,87 @@ def natPrim := ⟦
   -- decidable equality reduce natively in whnf, keeping evaluator-grade
   -- string values out of the structural ByteArray/UTF-8 model.
   fn string_append_addr() -> Addr {
-    store([0xb6u8, 0xecu8, 0x2du8, 0x44u8, 0x3fu8, 0x3eu8, 0xe6u8, 0x1du8,
-     0xe4u8, 0x5au8, 0xd8u8, 0x59u8, 0xb8u8, 0xccu8, 0x41u8, 0xa8u8,
-     0x96u8, 0xd8u8, 0xfbu8, 0xa4u8, 0x9bu8, 0xc2u8, 0x98u8, 0x83u8,
-     0xfcu8, 0x34u8, 0xc4u8, 0x27u8, 0xdbu8, 0xdfu8, 0x71u8, 0xf8u8])
+    store([0x13u8, 0x2fu8, 0x11u8, 0x75u8, 0xccu8, 0x3cu8, 0xacu8, 0x5au8,
+     0x3eu8, 0x3du8, 0x74u8, 0xe8u8, 0x79u8, 0x7fu8, 0x9bu8, 0xa6u8,
+     0x7fu8, 0x2eu8, 0x46u8, 0x7bu8, 0x80u8, 0x04u8, 0xa3u8, 0xf2u8,
+     0x8bu8, 0xb5u8, 0xdfu8, 0xd1u8, 0x6au8, 0x36u8, 0x47u8, 0xb1u8])
   }
 
   fn string_of_list_addr() -> Addr {
-    store([0xd5u8, 0x4du8, 0xb7u8, 0x1fu8, 0xeeu8, 0x55u8, 0x31u8, 0x1au8,
-     0xafu8, 0xeeu8, 0xadu8, 0x74u8, 0x76u8, 0x8eu8, 0x6eu8, 0x95u8,
-     0x22u8, 0x62u8, 0xc2u8, 0x9au8, 0xbdu8, 0x24u8, 0xb9u8, 0x31u8,
-     0x9fu8, 0xa6u8, 0x85u8, 0x94u8, 0x81u8, 0xddu8, 0x44u8, 0xb8u8])
+    store([0x27u8, 0x2eu8, 0xa5u8, 0xceu8, 0x6bu8, 0xabu8, 0x89u8, 0x58u8,
+     0x16u8, 0x5cu8, 0x7fu8, 0x56u8, 0xd7u8, 0x1fu8, 0xfeu8, 0x2au8,
+     0x5bu8, 0x17u8, 0x5eu8, 0xd5u8, 0x81u8, 0x10u8, 0x12u8, 0x6du8,
+     0xfau8, 0x96u8, 0xe1u8, 0xf8u8, 0xa0u8, 0xc9u8, 0x9au8, 0xd2u8])
   }
 
   fn char_of_nat_addr() -> Addr {
-    store([0x29u8, 0x56u8, 0x3du8, 0xa2u8, 0x71u8, 0xc2u8, 0x3fu8, 0x66u8,
-     0xb2u8, 0x7du8, 0x05u8, 0xf9u8, 0x24u8, 0xfbu8, 0x06u8, 0x12u8,
-     0x27u8, 0x2du8, 0xcfu8, 0xbau8, 0x6bu8, 0x10u8, 0x83u8, 0xb3u8,
-     0x48u8, 0x73u8, 0x3eu8, 0x00u8, 0xf9u8, 0xb3u8, 0x6bu8, 0x2au8])
+    store([0xcau8, 0xf5u8, 0x1bu8, 0x03u8, 0x9du8, 0x71u8, 0xcfu8, 0xceu8,
+     0x70u8, 0x63u8, 0xe1u8, 0x06u8, 0x06u8, 0x4fu8, 0x94u8, 0x35u8,
+     0xf5u8, 0x33u8, 0x7bu8, 0xbcu8, 0x42u8, 0x56u8, 0x7cu8, 0x8cu8,
+     0x78u8, 0xb5u8, 0xf6u8, 0x6cu8, 0x7fu8, 0x08u8, 0x79u8, 0x20u8])
   }
 
   fn list_nil_addr() -> Addr {
-    store([0x3cu8, 0x01u8, 0x49u8, 0xc3u8, 0x43u8, 0x29u8, 0x69u8, 0xeeu8,
-     0x5du8, 0x93u8, 0x54u8, 0xc8u8, 0xd2u8, 0xd8u8, 0x9cu8, 0xeeu8,
-     0xc4u8, 0xa7u8, 0x97u8, 0x11u8, 0xf8u8, 0xdeu8, 0xc8u8, 0x71u8,
-     0x08u8, 0x79u8, 0xa1u8, 0x2au8, 0x12u8, 0xb7u8, 0x2cu8, 0x42u8])
+    store([0x39u8, 0x94u8, 0xbcu8, 0x51u8, 0xe3u8, 0x68u8, 0x6fu8, 0x30u8,
+     0xa1u8, 0xd4u8, 0x83u8, 0xd6u8, 0x9du8, 0x0au8, 0x83u8, 0x5au8,
+     0x7bu8, 0x48u8, 0x4du8, 0x89u8, 0x23u8, 0x93u8, 0xc0u8, 0x84u8,
+     0xf8u8, 0x7au8, 0x58u8, 0x49u8, 0xdeu8, 0x54u8, 0xf3u8, 0x02u8])
   }
 
   fn list_cons_addr() -> Addr {
-    store([0xd1u8, 0xe0u8, 0x80u8, 0x2cu8, 0x38u8, 0xbcu8, 0xdau8, 0x14u8,
-     0x06u8, 0x1eu8, 0x20u8, 0x12u8, 0xf1u8, 0x2eu8, 0x73u8, 0xc2u8,
-     0xa2u8, 0x4au8, 0x67u8, 0x11u8, 0x37u8, 0x98u8, 0x4fu8, 0x8eu8,
-     0xf7u8, 0x67u8, 0x44u8, 0xeau8, 0x04u8, 0xd1u8, 0x88u8, 0xc4u8])
+    store([0xb3u8, 0xa7u8, 0xd8u8, 0x02u8, 0x49u8, 0xfdu8, 0x82u8, 0x31u8,
+     0x00u8, 0xeeu8, 0x03u8, 0x62u8, 0x62u8, 0x32u8, 0xd1u8, 0x41u8,
+     0x2au8, 0x0eu8, 0x83u8, 0x35u8, 0x27u8, 0x5du8, 0x5du8, 0xf5u8,
+     0x3bu8, 0x92u8, 0x94u8, 0x38u8, 0x87u8, 0xb6u8, 0x50u8, 0xf7u8])
   }
 
   fn char_type_addr() -> Addr {
-    store([0xd5u8, 0x54u8, 0x29u8, 0x72u8, 0x5au8, 0x19u8, 0xc1u8, 0x83u8,
-     0x7bu8, 0x34u8, 0x62u8, 0x4fu8, 0xb3u8, 0x57u8, 0x84u8, 0xb9u8,
-     0x1bu8, 0xc8u8, 0xb0u8, 0xe2u8, 0xd7u8, 0x9fu8, 0x98u8, 0xb3u8,
-     0xc2u8, 0x96u8, 0x31u8, 0x7fu8, 0xb6u8, 0xc5u8, 0xc7u8, 0x89u8])
+    store([0x4cu8, 0x59u8, 0xbcu8, 0x4eu8, 0xacu8, 0x82u8, 0xd3u8, 0x1eu8,
+     0xbeu8, 0xd5u8, 0x9bu8, 0xb2u8, 0x06u8, 0x90u8, 0x9du8, 0xbdu8,
+     0xedu8, 0x65u8, 0xb9u8, 0x2fu8, 0xd5u8, 0x6du8, 0xe2u8, 0x51u8,
+     0x8fu8, 0xcdu8, 0xadu8, 0xb0u8, 0xa4u8, 0x2cu8, 0x11u8, 0xa0u8])
   }
 
   fn string_back_addr() -> Addr {
-    store([0x3fu8, 0x92u8, 0xa4u8, 0x6au8, 0x14u8, 0x51u8, 0xfdu8, 0x66u8,
-     0x21u8, 0x5au8, 0xaeu8, 0x9cu8, 0xf7u8, 0x89u8, 0xceu8, 0x38u8,
-     0xa2u8, 0xc7u8, 0x3fu8, 0xddu8, 0x55u8, 0x90u8, 0x9du8, 0x45u8,
-     0x4fu8, 0x61u8, 0x25u8, 0x96u8, 0x34u8, 0xd9u8, 0x0bu8, 0x6bu8])
+    store([0x32u8, 0x10u8, 0x4bu8, 0x03u8, 0x34u8, 0x8du8, 0x11u8, 0xacu8,
+     0xb2u8, 0x43u8, 0x7fu8, 0xdau8, 0x24u8, 0x96u8, 0x6du8, 0xc5u8,
+     0x8cu8, 0xc8u8, 0xc8u8, 0xbcu8, 0xcau8, 0x96u8, 0x58u8, 0x26u8,
+     0x14u8, 0xe6u8, 0x44u8, 0xd3u8, 0x19u8, 0xa4u8, 0x2cu8, 0x62u8])
   }
 
   fn string_legacy_back_addr() -> Addr {
-    store([0xa2u8, 0xa3u8, 0x10u8, 0x13u8, 0x3du8, 0x17u8, 0x37u8, 0x1au8,
-     0xf6u8, 0x7cu8, 0xd9u8, 0x1du8, 0x27u8, 0x9au8, 0xafu8, 0x73u8,
-     0x5fu8, 0xa8u8, 0xcbu8, 0x81u8, 0x0cu8, 0x39u8, 0xaau8, 0xa8u8,
-     0x24u8, 0xa4u8, 0x43u8, 0xc6u8, 0x52u8, 0xe3u8, 0xdfu8, 0x66u8])
+    store([0x37u8, 0xefu8, 0x5fu8, 0xeeu8, 0x76u8, 0x5du8, 0xc2u8, 0xe5u8,
+     0xc7u8, 0x42u8, 0x5cu8, 0x18u8, 0x0cu8, 0xd4u8, 0x20u8, 0x07u8,
+     0xdbu8, 0x7du8, 0x29u8, 0xaeu8, 0x0du8, 0x5cu8, 0x09u8, 0x17u8,
+     0x89u8, 0xf4u8, 0x62u8, 0xf2u8, 0x80u8, 0x5bu8, 0x0eu8, 0x09u8])
   }
 
   fn string_to_byte_array_addr() -> Addr {
-    store([0xadu8, 0x70u8, 0x0cu8, 0x08u8, 0x06u8, 0xe6u8, 0x73u8, 0xe7u8,
-     0x4au8, 0xdcu8, 0xafu8, 0xc2u8, 0x8cu8, 0xa6u8, 0x59u8, 0xd3u8,
-     0x0au8, 0x61u8, 0x66u8, 0x33u8, 0xa4u8, 0xa3u8, 0x64u8, 0x20u8,
-     0x32u8, 0x4fu8, 0xc2u8, 0x9eu8, 0xaeu8, 0x69u8, 0xebu8, 0x9cu8])
+    store([0x79u8, 0x86u8, 0x2au8, 0xcfu8, 0xbcu8, 0x2eu8, 0x37u8, 0xb7u8,
+     0xb6u8, 0x12u8, 0x21u8, 0x43u8, 0xf0u8, 0xa6u8, 0xa5u8, 0x11u8,
+     0x14u8, 0xc3u8, 0x4fu8, 0xa4u8, 0x83u8, 0xffu8, 0x14u8, 0x14u8,
+     0x64u8, 0x83u8, 0xdeu8, 0x18u8, 0x83u8, 0x5du8, 0x42u8, 0x09u8])
   }
 
   fn byte_array_empty_addr() -> Addr {
-    store([0xd8u8, 0x38u8, 0xbbu8, 0x6bu8, 0xb6u8, 0x51u8, 0x53u8, 0x30u8,
-     0x81u8, 0xacu8, 0x24u8, 0x95u8, 0xa2u8, 0x5du8, 0x69u8, 0x0cu8,
-     0x54u8, 0xf8u8, 0xe3u8, 0x45u8, 0xffu8, 0xf4u8, 0x1eu8, 0xfbu8,
-     0xd5u8, 0x58u8, 0x5eu8, 0xb4u8, 0x68u8, 0x70u8, 0x53u8, 0x08u8])
+    store([0xbfu8, 0x58u8, 0xe6u8, 0xcbu8, 0x3au8, 0xa0u8, 0xf7u8, 0x46u8,
+     0x85u8, 0x06u8, 0x29u8, 0x04u8, 0x16u8, 0x35u8, 0xcdu8, 0x30u8,
+     0xc0u8, 0xadu8, 0x66u8, 0x26u8, 0x2bu8, 0x66u8, 0x17u8, 0x66u8,
+     0x0fu8, 0x22u8, 0x90u8, 0x24u8, 0x1fu8, 0x08u8, 0xb0u8, 0x8bu8])
   }
 
   fn string_dec_eq_addr() -> Addr {
-    store([0xd6u8, 0x16u8, 0x32u8, 0x7du8, 0x4fu8, 0xc2u8, 0x19u8, 0xbdu8,
-     0x71u8, 0x14u8, 0xbau8, 0xd4u8, 0x6cu8, 0xd0u8, 0x86u8, 0x6bu8,
-     0xefu8, 0xe2u8, 0x55u8, 0x15u8, 0x18u8, 0xb5u8, 0xbfu8, 0x2eu8,
-     0x10u8, 0xb5u8, 0xcau8, 0xc9u8, 0x33u8, 0x81u8, 0xfbu8, 0x77u8])
+    store([0x19u8, 0x13u8, 0x4fu8, 0xdcu8, 0x18u8, 0x8eu8, 0x83u8, 0x77u8,
+     0xd0u8, 0x17u8, 0x38u8, 0x57u8, 0xe1u8, 0x5du8, 0x3bu8, 0x50u8,
+     0x65u8, 0xedu8, 0x76u8, 0xdau8, 0x98u8, 0x13u8, 0x97u8, 0x10u8,
+     0x7eu8, 0x5cu8, 0x40u8, 0x4du8, 0xb3u8, 0xf3u8, 0xb7u8, 0x18u8])
   }
 
   fn string_type_addr() -> Addr {
-    store([0x42u8, 0x88u8, 0xf9u8, 0x2eu8, 0xd1u8, 0xd5u8, 0x1fu8, 0x49u8,
-     0x35u8, 0xe5u8, 0xd2u8, 0x77u8, 0x5fu8, 0x33u8, 0xecu8, 0x58u8,
-     0x5du8, 0x6fu8, 0xe5u8, 0xecu8, 0x63u8, 0xdau8, 0xdfu8, 0x0eu8,
-     0xa6u8, 0x98u8, 0x55u8, 0x44u8, 0x78u8, 0xfdu8, 0x9fu8, 0xadu8])
+    store([0x9du8, 0x6au8, 0xe4u8, 0x34u8, 0x29u8, 0xecu8, 0x02u8, 0xa9u8,
+     0x33u8, 0x8bu8, 0xbcu8, 0xd0u8, 0xdbu8, 0x0au8, 0xc1u8, 0x93u8,
+     0xd7u8, 0x5eu8, 0xbdu8, 0x46u8, 0xf8u8, 0x84u8, 0xbfu8, 0xcbu8,
+     0xd2u8, 0xc4u8, 0x2bu8, 0xf7u8, 0xfau8, 0xeau8, 0x15u8, 0x0du8])
   }
 
   -- Address is a string primitive.
@@ -1944,3 +1944,4 @@ def natPrim := ⟦
 end IxVM
 
 end
+
diff --git a/Ix/IxVM/Kernel/Whnf.lean b/Ix/IxVM/Kernel/Whnf.lean
index bd89e681c..c22b4c9f1 100644
--- a/Ix/IxVM/Kernel/Whnf.lean
+++ b/Ix/IxVM/Kernel/Whnf.lean
@@ -128,24 +128,24 @@ def whnf := ⟦
   }
 
   fn fin_addr() -> Addr {
-    store([0xa7u8, 0xe9u8, 0xa8u8, 0xb8u8, 0x4au8, 0x2fu8, 0xe9u8, 0x6cu8,
-     0xc2u8, 0x04u8, 0xacu8, 0xc9u8, 0x3du8, 0x7eu8, 0xd1u8, 0x36u8,
-     0x6du8, 0x9du8, 0x05u8, 0x74u8, 0xaau8, 0xf0u8, 0xf0u8, 0x96u8,
-     0x33u8, 0xd2u8, 0xb0u8, 0x9au8, 0x94u8, 0xc9u8, 0xe8u8, 0x60u8])
+    store([0x3du8, 0x79u8, 0x79u8, 0x7bu8, 0xc5u8, 0x72u8, 0xd8u8, 0xf3u8,
+     0x3eu8, 0xb7u8, 0xcfu8, 0xf5u8, 0xaau8, 0x13u8, 0xf8u8, 0xdcu8,
+     0x73u8, 0xbcu8, 0xf2u8, 0x10u8, 0x26u8, 0xbfu8, 0x05u8, 0xd0u8,
+     0x38u8, 0x88u8, 0xc9u8, 0xaau8, 0x03u8, 0x69u8, 0xdcu8, 0xefu8])
   }
 
   fn decidable_rec_addr() -> Addr {
-    store([0x6au8, 0xf7u8, 0x38u8, 0x09u8, 0xa6u8, 0x12u8, 0x8au8, 0xdcu8,
-     0xb9u8, 0xc5u8, 0xd7u8, 0xe7u8, 0x3au8, 0x30u8, 0xc2u8, 0x8du8,
-     0x48u8, 0x9du8, 0xbau8, 0x4du8, 0x90u8, 0x57u8, 0x17u8, 0x05u8,
-     0x5au8, 0xc2u8, 0xedu8, 0xd7u8, 0x55u8, 0xffu8, 0xa7u8, 0x13u8])
+    store([0x16u8, 0xcfu8, 0xddu8, 0xdau8, 0x9cu8, 0x27u8, 0x46u8, 0x60u8,
+     0xf3u8, 0x91u8, 0xb1u8, 0x0eu8, 0xefu8, 0xe0u8, 0x66u8, 0x27u8,
+     0x5au8, 0xffu8, 0xfau8, 0xe1u8, 0xccu8, 0xd4u8, 0x9cu8, 0x6du8,
+     0xafu8, 0x43u8, 0xafu8, 0xb8u8, 0xa8u8, 0x0au8, 0xeau8, 0x85u8])
   }
 
   fn nat_ty_addr() -> Addr {
-    store([0x1du8, 0xffu8, 0xfdu8, 0xe4u8, 0x8cu8, 0x4eu8, 0xf6u8, 0x65u8,
-     0x3bu8, 0x95u8, 0xecu8, 0xc5u8, 0x47u8, 0x4du8, 0xeeu8, 0x8bu8,
-     0x99u8, 0x46u8, 0x10u8, 0x08u8, 0xd2u8, 0x6du8, 0x80u8, 0xcau8,
-     0x38u8, 0x4fu8, 0x1eu8, 0x59u8, 0xe9u8, 0x27u8, 0x71u8, 0x4du8])
+    store([0x35u8, 0xe1u8, 0xccu8, 0x80u8, 0x9fu8, 0x6fu8, 0x07u8, 0x65u8,
+     0x21u8, 0xa4u8, 0x3fu8, 0x85u8, 0x06u8, 0x8du8, 0x55u8, 0x92u8,
+     0x22u8, 0x04u8, 0x07u8, 0xc0u8, 0x53u8, 0x2bu8, 0x6au8, 0x08u8,
+     0x95u8, 0x2fu8, 0x40u8, 0xd8u8, 0x52u8, 0x3du8, 0x04u8, 0xbcu8])
   }
 
   -- The three quotient primitives reduction is allowed to fire on.
@@ -154,24 +154,24 @@ def whnf := ⟦
   -- resolves to the constant its name claims, so a drifted copy fails
   -- there rather than silently mis-reducing.
   fn quot_ctor_addr_iota() -> Addr {
-    store([0x0au8, 0x4cu8, 0xc7u8, 0xc9u8, 0x30u8, 0xddu8, 0x67u8, 0x26u8,
-     0xbbu8, 0xd7u8, 0xf1u8, 0xbcu8, 0x3fu8, 0xeau8, 0x68u8, 0x5du8,
-     0xf5u8, 0xf6u8, 0x66u8, 0x54u8, 0x9du8, 0x65u8, 0x1du8, 0x3eu8,
-     0x76u8, 0x6fu8, 0xe5u8, 0x74u8, 0x6eu8, 0xc4u8, 0x59u8, 0xa4u8])
+    store([0x81u8, 0x16u8, 0x00u8, 0xdfu8, 0xa5u8, 0x9fu8, 0x36u8, 0x12u8,
+     0xcbu8, 0x03u8, 0xc0u8, 0xf0u8, 0x47u8, 0x5au8, 0xf1u8, 0x52u8,
+     0x39u8, 0x9du8, 0xefu8, 0xffu8, 0x92u8, 0x26u8, 0xc6u8, 0xe1u8,
+     0x9fu8, 0xd6u8, 0x48u8, 0x04u8, 0x1au8, 0x68u8, 0x99u8, 0xa9u8])
   }
 
   fn quot_lift_addr_iota() -> Addr {
-    store([0x56u8, 0x02u8, 0x76u8, 0xf9u8, 0x5eu8, 0x0du8, 0x93u8, 0xe2u8,
-     0x7bu8, 0x8cu8, 0x05u8, 0x09u8, 0x79u8, 0x95u8, 0xbfu8, 0x82u8,
-     0x87u8, 0x63u8, 0x32u8, 0xc2u8, 0xe7u8, 0xe3u8, 0x10u8, 0x33u8,
-     0xe0u8, 0xa1u8, 0x94u8, 0x81u8, 0x9eu8, 0x4eu8, 0x8du8, 0x30u8])
+    store([0x86u8, 0xb3u8, 0x65u8, 0xe7u8, 0x5bu8, 0xb4u8, 0x23u8, 0x0fu8,
+     0x04u8, 0xc6u8, 0xe4u8, 0xf3u8, 0xa7u8, 0xcau8, 0x69u8, 0x88u8,
+     0xadu8, 0xf5u8, 0x74u8, 0x61u8, 0x6du8, 0x79u8, 0xa3u8, 0xd7u8,
+     0x47u8, 0x7au8, 0xd6u8, 0x5cu8, 0xacu8, 0x10u8, 0x21u8, 0x10u8])
   }
 
   fn quot_ind_addr_iota() -> Addr {
-    store([0x02u8, 0xf3u8, 0x58u8, 0x80u8, 0x8fu8, 0xd4u8, 0x32u8, 0x8du8,
-     0x74u8, 0x85u8, 0x05u8, 0x82u8, 0xd3u8, 0x60u8, 0x8du8, 0x2du8,
-     0x31u8, 0xe4u8, 0x95u8, 0x19u8, 0xb4u8, 0xc6u8, 0xc6u8, 0x6bu8,
-     0x36u8, 0x05u8, 0xfbu8, 0xe6u8, 0xf4u8, 0x2du8, 0x3cu8, 0x5du8])
+    store([0x17u8, 0x45u8, 0x49u8, 0x1cu8, 0x0du8, 0x65u8, 0x1du8, 0xe0u8,
+     0xbeu8, 0xa5u8, 0x89u8, 0xd5u8, 0xffu8, 0xfbu8, 0xc9u8, 0xbcu8,
+     0x4du8, 0x7fu8, 0xbeu8, 0x89u8, 0x7cu8, 0x1du8, 0x80u8, 0x5bu8,
+     0x1fu8, 0x7fu8, 0x59u8, 0xcau8, 0x96u8, 0x96u8, 0xa6u8, 0xefu8])
   }
 
   -- Mirror try_reduce_fin_val_decidable_rec (Primitive.lean:3141+).
@@ -608,17 +608,17 @@ def whnf := ⟦
   -- Canonical Nat.zero / Nat.succ addrs. Mirror
   -- crates/kernel/src, 490).
   fn nat_zero_addr_iota() -> Addr {
-    store([0x50u8, 0xe5u8, 0xd6u8, 0x9du8, 0x80u8, 0x6bu8, 0xc1u8, 0xc6u8,
-     0x16u8, 0xcau8, 0xceu8, 0x42u8, 0x30u8, 0xc9u8, 0x82u8, 0xa0u8,
-     0xeeu8, 0x5bu8, 0x35u8, 0x0bu8, 0x3eu8, 0xfeu8, 0x3bu8, 0x1au8,
-     0x15u8, 0x80u8, 0x1du8, 0xf7u8, 0x7fu8, 0xc0u8, 0x0cu8, 0x8cu8])
+    store([0xeeu8, 0xb2u8, 0xe6u8, 0x26u8, 0x8fu8, 0xf6u8, 0xd0u8, 0xe6u8,
+     0xb2u8, 0xe9u8, 0x76u8, 0x4du8, 0x99u8, 0x40u8, 0xb8u8, 0x1bu8,
+     0xb6u8, 0x4bu8, 0x9fu8, 0x8fu8, 0x4bu8, 0x13u8, 0x58u8, 0xd2u8,
+     0x94u8, 0xffu8, 0x98u8, 0x17u8, 0xe6u8, 0x94u8, 0x1au8, 0x46u8])
   }
 
   fn nat_succ_addr_iota() -> Addr {
-    store([0x8cu8, 0x09u8, 0xcau8, 0x64u8, 0x4bu8, 0x10u8, 0xdeu8, 0xcau8,
-     0xd1u8, 0x58u8, 0xd3u8, 0x70u8, 0x06u8, 0xe8u8, 0x1cu8, 0xdcu8,
-     0x1bu8, 0x84u8, 0x76u8, 0x13u8, 0x12u8, 0x26u8, 0x05u8, 0x46u8,
-     0x44u8, 0x9au8, 0xa0u8, 0x2eu8, 0x34u8, 0x3bu8, 0x2bu8, 0x0cu8])
+    store([0x42u8, 0xd6u8, 0xedu8, 0x31u8, 0x53u8, 0x6fu8, 0x09u8, 0x58u8,
+     0x17u8, 0x6fu8, 0x1du8, 0xc9u8, 0x73u8, 0x38u8, 0x38u8, 0x08u8,
+     0xacu8, 0x85u8, 0x83u8, 0x22u8, 0x37u8, 0x46u8, 0xebu8, 0xcau8,
+     0x78u8, 0xdbu8, 0xe3u8, 0x89u8, 0xb6u8, 0x53u8, 0x21u8, 0xa6u8])
   }
 
   -- Convert `Lit(Nat n)` to `Nat.zero` or `App(Nat.succ, Lit(n-1))`.
@@ -1401,3 +1401,4 @@ def whnf := ⟦
 end IxVM
 
 end
+
diff --git a/Ix/Ixon.lean b/Ix/Ixon.lean
index 4f8034c3d..e4f5f6487 100644
--- a/Ix/Ixon.lean
+++ b/Ix/Ixon.lean
@@ -11,7 +11,7 @@ module
 public import Ix.Address
 public import Ix.Common
 public import Ix.Environment
-public import Ix.IxonMode
+public import Ix.IxonContract
 public import Ix.Merkle
 
 public section
@@ -19,7 +19,7 @@ public section
 namespace Ixon
 
 /-- Stable identifier for the v2 Ixon wire grammar. -/
-def wireFormatId : String := "ixon-v2"
+def wireFormatId : String := "ixon-v3"
 
 /-! ## Serialization Monad and Typeclass -/
 
@@ -204,6 +204,8 @@ def getTag0 : GetM Tag0 := do
     getU64TrimmedLE (small.toNat + 1)
   else
     pure small.toUInt64
+  if large && (size < 128 || u64ByteCount size != small + 1) then
+    throw "noncanonical Tag0 integer"
   return ⟨size⟩
 
 /-- Tag2: 2-bit flag + size.
@@ -232,6 +234,8 @@ def getTag2 : GetM Tag2 := do
     getU64TrimmedLE (small.toNat + 1)
   else
     pure small.toUInt64
+  if large && (size < 32 || u64ByteCount size != small + 1) then
+    throw "noncanonical Tag2 integer"
   return ⟨flag, size⟩
 
 /-- Tag4: 4-bit flag + size.
@@ -260,12 +264,41 @@ def getTag4 : GetM Tag4 := do
     getU64TrimmedLE (small.toNat + 1)
   else
     pure small.toUInt64
+  if large && (size < 8 || u64ByteCount size != small + 1) then
+    throw "noncanonical Tag4 integer"
   return ⟨flag, size⟩
 
 instance : Serialize Tag4 where
   put := putTag4
   get := getTag4
 
+/-! ## Contract serialization -/
+
+/-- Counts must fit the remaining input before a reader allocates or iterates. -/
+def checkCount (count : UInt64) (minBytes : Nat := 1) : GetM Unit := do
+  let st ← get
+  if count.toNat * minBytes > st.bytes.size - st.idx then
+    throw "count exceeds remaining bytes"
+
+def putValueContract (v : ValueContract) : PutM Unit := putU8 v.toBits
+
+def getValueContract : GetM ValueContract := do
+  let bits ← getU8
+  let some contract := ValueContract.ofBits? bits
+    | throw s!"invalid value contract {bits}"
+  return contract
+
+def putBinderContract (b : BinderContract) : PutM Unit := putU8 b.toBits
+
+def getBinderContract : GetM BinderContract := do
+  let bits ← getU8
+  let some contract := BinderContract.ofBits? bits
+    | throw s!"invalid binder contract {bits}"
+  return contract
+
+instance : Serialize ValueContract := ⟨putValueContract, getValueContract⟩
+instance : Serialize BinderContract := ⟨putBinderContract, getBinderContract⟩
+
 /-! ## Universe Levels -/
 
 /-- Universe levels for Lean's type system. -/
@@ -298,9 +331,9 @@ inductive Expr where
   | str : UInt64 → Expr
   | nat : UInt64 → Expr
   | app : Expr → Expr → Expr
-  | lam : Uses → Expr → Expr → Expr
-  | all : Uses → Owned → Expr → Expr → Expr
-  | letE : Bool → Expr → Expr → Expr → Expr
+  | lam : BinderContract → Expr → Expr → Expr
+  | all : BinderContract → ValueContract → Expr → Expr → Expr
+  | letE : LetContract → Expr → Expr → Expr → Expr
   | share : UInt64 → Expr
   deriving BEq, Repr, Inhabited, Hashable
 
@@ -318,22 +351,28 @@ namespace Expr
   def FLAG_LET : UInt8 := 0xA
   def FLAG_SHARE : UInt8 := 0xB
 
-  /-- Embed an ordinary Lean lambda in Ixon v2. -/
+  /-- Embed an ordinary Lean lambda in Ixon v3. -/
   def leanLam (ty body : Expr) : Expr := .lam .many ty body
 
-  /-- Embed an ordinary Lean forall in Ixon v2. -/
+  /-- Embed an ordinary Lean forall in Ixon v3. -/
   def leanAll (ty body : Expr) : Expr := .all .many .shared ty body
 
-  /-- The mode-free Lean fragment embedded in Ixon v2. -/
+  /-- Embed an ordinary Lean let with default contracts. -/
+  def leanLet (nonDep : Bool) (ty val body : Expr) : Expr :=
+    .letE (.lean nonDep) ty val body
+
+  /-- The ordinary Lean fragment uses explicit default contracts. -/
   def leanFragment : Expr → Bool
-    | .lam .many ty body => leanFragment ty && leanFragment body
-    | .lam .. => false
-    | .all .many .shared ty body => leanFragment ty && leanFragment body
-    | .all .. => false
+    | .lam contract ty body =>
+      contract == BinderContract.many && leanFragment ty && leanFragment body
+    | .all contract result ty body =>
+      contract == BinderContract.many && result == ValueContract.shared &&
+        leanFragment ty && leanFragment body
     | .app fn arg => leanFragment fn && leanFragment arg
     | .prj _ _ val => leanFragment val
-    | .letE _ ty val body =>
-      leanFragment ty && leanFragment val && leanFragment body
+    | .letE contract ty val body =>
+      contract.kind == .value && contract.binder == BinderContract.many &&
+        leanFragment ty && leanFragment val && leanFragment body
     | _ => true
 end Expr
 
@@ -838,14 +877,14 @@ instance : Serialize Univ where
 /-! ## Expr Serialization -/
 
 /-- Collect all mode/type pairs in a lambda telescope. -/
-def Expr.collectLamBinders : Expr → List (Uses × Expr) × Expr
+def Expr.collectLamBinders : Expr → List (BinderContract × Expr) × Expr
   | .lam uses ty body =>
     let (binders, base) := body.collectLamBinders
     ((uses, ty) :: binders, base)
   | e => ([], e)
 
 /-- Collect all mode/type triples in a forall telescope. -/
-def Expr.collectAllBinders : Expr → List (Uses × Owned × Expr) × Expr
+def Expr.collectAllBinders : Expr → List (BinderContract × ValueContract × Expr) × Expr
   | .all uses owned ty body =>
     let (binders, base) := body.collectAllBinders
     ((uses, owned, ty) :: binders, base)
@@ -883,7 +922,7 @@ theorem Expr.collectLamBinders_base_nodeCount_le (e : Expr) :
     exact Nat.le_refl _
 
 /-- A lambda telescope's base has fewer nodes than a lambda node. -/
-theorem Expr.collectLamBinders_base_nodeCount_lt (uses : Uses)
+theorem Expr.collectLamBinders_base_nodeCount_lt (uses : BinderContract)
     (binder body : Expr) :
     (Expr.lam uses binder body).collectLamBinders.2.nodeCount <
       (Expr.lam uses binder body).nodeCount := by
@@ -925,7 +964,7 @@ theorem Expr.collectAllBinders_base_nodeCount_le (e : Expr) :
     exact Nat.le_refl _
 
 /-- A forall telescope's base has fewer nodes than a forall node. -/
-theorem Expr.collectAllBinders_base_nodeCount_lt (uses : Uses) (owned : Owned)
+theorem Expr.collectAllBinders_base_nodeCount_lt (uses : BinderContract) (owned : ValueContract)
     (binder body : Expr) :
     (Expr.all uses owned binder body).collectAllBinders.2.nodeCount <
       (Expr.all uses owned binder body).nodeCount := by
@@ -1011,7 +1050,7 @@ private theorem nodeCount_right_lt_sum3 (left middle right : Nat) :
   Nat.lt_of_le_of_lt (Nat.le_add_left right (left + middle))
     (Nat.lt_succ_self _)
 
-/-- Total canonical v2 expression writer. Telescope collection preserves the
+/-- Total canonical v3 expression writer. Telescope collection preserves the
     Rust byte grammar; the node-count lemmas above expose its recursive calls
     to the kernel termination checker. -/
 def putExpr : Expr → PutM Unit
@@ -1047,11 +1086,12 @@ def putExpr : Expr → PutM Unit
   | e@(.all _ _ _ _) => do
     putTag4 ⟨Expr.FLAG_ALL, e.collectAllBinders.1.length.toUInt64⟩
     for binder in e.collectAllBinders.1 do
-      putU8 (binder.1.toBits ||| (binder.2.1.toBits <<< 2))
+      putU8 (packAllContract binder.1 binder.2.1)
       putExpr binder.2.2
     putExpr e.collectAllBinders.2
-  | .letE nonDep ty val body => do
-    putTag4 ⟨Expr.FLAG_LET, if nonDep then 1 else 0⟩
+  | .letE contract ty val body => do
+    putTag4 ⟨Expr.FLAG_LET, contract.flags⟩
+    putBinderContract contract.binder
     putExpr ty
     putExpr val
     putExpr body
@@ -1103,33 +1143,27 @@ def getExprAppArgs (recur : GetM Expr) : Nat → Expr → GetM Expr
     getExprAppArgs recur count (.app result arg)
 
 /-- Read a lambda telescope in outer-to-inner wire order. -/
-def getExprLamBinders (recur : GetM Expr) : Nat → GetM (List (Uses × Expr))
+def getExprLamBinders (recur : GetM Expr) : Nat → GetM (List (BinderContract × Expr))
   | 0 => pure []
   | count + 1 => do
-    let mode ← getU8
-    let some uses := Uses.ofBits? mode
-      | throw s!"getExpr: invalid lambda mode {mode}"
+    let contract ← getBinderContract
     let ty ← recur
     let tail ← getExprLamBinders recur count
-    return (uses, ty) :: tail
+    return (contract, ty) :: tail
 
 /-- Read a forall telescope in outer-to-inner wire order. -/
 def getExprAllBinders (recur : GetM Expr) :
-    Nat → GetM (List (Uses × Owned × Expr))
+    Nat → GetM (List (BinderContract × ValueContract × Expr))
   | 0 => pure []
   | count + 1 => do
-    let mode ← getU8
-    if mode > 7 then
-      throw s!"getExpr: invalid forall mode {mode}"
-    let some uses := Uses.ofBits? (mode &&& 0x03)
-      | throw s!"getExpr: invalid forall usage mode {mode}"
-    let some owned := Owned.ofBits? ((mode >>> 2) &&& 0x01)
-      | throw s!"getExpr: invalid forall ownership mode {mode}"
+    let bits ← getU8
+    let some (contract, result) := unpackAllContract? bits
+      | throw s!"getExpr: invalid forall contract {bits}"
     let ty ← recur
     let tail ← getExprAllBinders recur count
-    return (uses, owned, ty) :: tail
+    return (contract, result, ty) :: tail
 
-/-- Parse a v2 expression after its leading `Tag4`. Recursive reads are
+/-- Parse a v3 expression after its leading `Tag4`. Recursive reads are
     supplied explicitly so `getExprFuel` below remains structurally total. -/
 def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do
   match tag.flag with
@@ -1137,10 +1171,12 @@ def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do
   | 0x1 => return .var tag.size
   | 0x2 => do  -- REF: tag.size is array_len, then ref_idx, then elements
     let refIdx := (← getTag0).size
+    checkCount tag.size
     let univIdxs ← getTag0Sizes tag.size.toNat
     return .ref refIdx univIdxs.toArray
   | 0x3 => do  -- REC: tag.size is array_len, then rec_idx, then elements
     let recIdx := (← getTag0).size
+    checkCount tag.size
     let univIdxs ← getTag0Sizes tag.size.toNat
     return .recur recIdx univIdxs.toArray
   | 0x4 => do  -- PRJ: tag.size is field_idx, then type_ref_idx, then val
@@ -1152,6 +1188,7 @@ def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do
   | 0x7 => do  -- APP (telescope)
     if tag.size == 0 then
       throw "getExpr: empty app spine"
+    checkCount tag.size
     let base ← recur
     match base with
     | .app .. => throw "getExpr: non-canonical app base"
@@ -1160,6 +1197,7 @@ def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do
   | 0x8 => do  -- LAM (telescope)
     if tag.size == 0 then
       throw "getExpr: Lam with zero binders"
+    checkCount tag.size 2
     let binders ← getExprLamBinders recur tag.size.toNat
     let body ← recur
     match body with
@@ -1169,6 +1207,7 @@ def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do
   | 0x9 => do  -- ALL (telescope)
     if tag.size == 0 then
       throw "getExpr: All with zero binders"
+    checkCount tag.size 2
     let binders ← getExprAllBinders recur tag.size.toNat
     let body ← recur
     match body with
@@ -1177,17 +1216,19 @@ def getExprFromTag (recur : GetM Expr) (tag : Tag4) : GetM Expr := do
     return binders.foldr
       (fun (uses, owned, ty) result => .all uses owned ty result) body
   | 0xA => do  -- LET
-    if tag.size > 1 then
-      throw s!"getExpr: invalid letE nonDep {tag.size}"
-    let nonDep := tag.size == 1
+    if tag.size > 3 then
+      throw s!"getExpr: invalid let flags {tag.size}"
+    let binder ← getBinderContract
+    let some contract := LetContract.ofFlags? tag.size binder
+      | throw "getExpr: invalid let flags"
     let ty ← recur
     let val ← recur
     let body ← recur
-    return .letE nonDep ty val body
+    return .letE contract ty val body
   | 0xB => return .share tag.size
   | f => throw s!"getExpr: invalid flag {f}"
 
-/-- Total v2 expression reader. Every recursive layer consumes a `Tag4`
+/-- Total v3 expression reader. Every recursive layer consumes a `Tag4`
     header, so a caller-supplied byte budget is a complete termination
     measure even for telescope-compressed applications and binders. -/
 def getExprFuel : Nat → GetM Expr
@@ -1230,7 +1271,10 @@ def putDefinition (d : Definition) : PutM Unit := do
   putExpr d.value
 
 def getDefinition : GetM Definition := do
-  let (kind, safety) := unpackDefKindSafety (← getU8)
+  let flags ← getU8
+  if flags >>> 2 > 2 || (flags &&& 3) > 2 then
+    throw "invalid definition kind/safety"
+  let (kind, safety) := unpackDefKindSafety flags
   let lvls := (← getTag0).size
   let typ ← getExpr
   let value ← getExpr
@@ -1265,7 +1309,9 @@ def putRecursor (r : Recursor) : PutM Unit := do
   for rule in r.rules do putRecursorRule rule
 
 def getRecursor : GetM Recursor := do
-  let bools := unpackBools 2 (← getU8)
+  let flags ← getU8
+  if flags > 3 then throw "invalid recursor flags"
+  let bools := unpackBools 2 flags
   let k := bools[0]!
   let isUnsafe := bools[1]!
   let lvls := (← getTag0).size
@@ -1275,6 +1321,7 @@ def getRecursor : GetM Recursor := do
   let minors := (← getTag0).size
   let typ ← getExpr
   let numRules := (← getTag0).size.toNat
+  checkCount numRules.toUInt64 2
   let mut rules := #[]
   for _ in [0:numRules] do
     rules := rules.push (← getRecursorRule)
@@ -1290,7 +1337,7 @@ def putAxiom (a : Axiom) : PutM Unit := do
   putExpr a.typ
 
 def getAxiom : GetM Axiom := do
-  let isUnsafe := (← getU8) != 0
+  let isUnsafe ← Serialize.get
   let lvls := (← getTag0).size
   let typ ← getExpr
   return ⟨isUnsafe, lvls, typ⟩
@@ -1327,7 +1374,7 @@ def putConstructor (c : Constructor) : PutM Unit := do
   putExpr c.typ
 
 def getConstructor : GetM Constructor := do
-  let isUnsafe := (← getU8) != 0
+  let isUnsafe ← Serialize.get
   let lvls := (← getTag0).size
   let cidx := (← getTag0).size
   let params := (← getTag0).size
@@ -1349,13 +1396,13 @@ def putInductive (i : Inductive) : PutM Unit := do
   for c in i.ctors do putConstructor c
 
 def getInductive : GetM Inductive := do
-  let bools := unpackBools 1 (← getU8)
-  let isUnsafe := bools[0]!
+  let isUnsafe ← Serialize.get
   let lvls := (← getTag0).size
   let params := (← getTag0).size
   let indices := (← getTag0).size
   let typ ← getExpr
   let numCtors := (← getTag0).size.toNat
+  checkCount numCtors.toUInt64 6
   let mut ctors := #[]
   for _ in [0:numCtors] do
     ctors := ctors.push (← getConstructor)
@@ -2520,7 +2567,7 @@ structure RawEnv where
 namespace RawEnv
 
 /-- Recursively add all name components to the names map.
-    Uses Ix.Name.getHash for address computation. -/
+    BinderContract Ix.Name.getHash for address computation. -/
 partial def addNameComponents (names : Std.HashMap Address Ix.Name) (name : Ix.Name) : Std.HashMap Address Ix.Name :=
   let addr := name.getHash
   if names.contains addr then names
@@ -2611,7 +2658,7 @@ def FLAG : UInt8 := 0xE
     mismatch and there is no back-compat reading of old versions —
     `.ixe` files are regenerated artifacts. Mirrors Rust
     `Env::VERSION` in `crates/ixon/src/serialize.rs`. -/
-def VERSION : UInt64 := 2
+def VERSION : UInt64 := 3
 
 /-- Serialize a name component (references parent by address).
     Format: tag (1 byte) + parent_addr (32 bytes) + data -/
diff --git a/Ix/IxonContract.lean b/Ix/IxonContract.lean
new file mode 100644
index 000000000..3208ed196
--- /dev/null
+++ b/Ix/IxonContract.lean
@@ -0,0 +1,222 @@
+module
+public import Ix.IxonMode
+
+/-!
+# Relative locality and value contracts
+
+Usage, ownership, and locality are independent. Local scopes and loan origins
+are tracked by the checker; contracts contain no named lifetime parameters.
+-/
+
+@[expose] public section
+
+namespace Ixon
+
+inductive Locality where
+  | unrestricted
+  | local
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable
+
+instance : ReflBEq Locality where
+  rfl := by intro l; cases l <;> rfl
+
+instance : LawfulBEq Locality where
+  eq_of_beq := by
+    intro left right h
+    cases left <;> cases right <;>
+      first | rfl | exact Bool.noConfusion h
+
+namespace Locality
+
+def toBits : Locality → UInt8
+  | .unrestricted => 0
+  | .local => 1
+
+def ofBits? : UInt8 → Option Locality
+  | 0 => some .unrestricted
+  | 1 => some .local
+  | _ => none
+
+@[simp] theorem ofBits?_toBits (l : Locality) : ofBits? l.toBits = some l := by
+  cases l <;> rfl
+
+end Locality
+
+structure ValueContract where
+  owned : Owned := .shared
+  locality : Locality := .unrestricted
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable
+
+instance : ReflBEq ValueContract where
+  rfl := by
+    rintro ⟨owned, locality⟩
+    cases owned <;> cases locality <;> rfl
+
+instance : LawfulBEq ValueContract where
+  eq_of_beq := by
+    rintro ⟨owned, locality⟩ ⟨owned', locality'⟩ h
+    cases owned <;> cases locality <;> cases owned' <;> cases locality' <;>
+      first | rfl | exact Bool.noConfusion h
+
+namespace ValueContract
+
+def shared : ValueContract := {}
+def unique : ValueContract := { owned := .unique }
+def localShared : ValueContract := { locality := .local }
+def localUnique : ValueContract := { owned := .unique, locality := .local }
+
+/-- `! = 0`, unmarked = 1, `~! = 2`, `~ = 3`. -/
+def toBits (v : ValueContract) : UInt8 :=
+  v.owned.toBits ||| (v.locality.toBits <<< 1)
+
+def ofBits? (bits : UInt8) : Option ValueContract := do
+  if bits > 3 then none else
+    return ⟨← Owned.ofBits? (bits &&& 1), ← Locality.ofBits? (bits >>> 1)⟩
+
+@[simp] theorem ofBits?_toBits (v : ValueContract) :
+    ofBits? v.toBits = some v := by
+  rcases v with ⟨owned, locality⟩
+  cases owned <;> cases locality <;> rfl
+
+end ValueContract
+
+structure BinderContract where
+  uses : Uses := .many
+  value : ValueContract := .shared
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable
+
+instance : ReflBEq BinderContract where
+  rfl := by
+    rintro ⟨uses, owned, locality⟩
+    cases uses <;> cases owned <;> cases locality <;> rfl
+
+instance : LawfulBEq BinderContract where
+  eq_of_beq := by
+    rintro ⟨uses, owned, locality⟩ ⟨uses', owned', locality'⟩ h
+    cases uses <;> cases owned <;> cases locality <;>
+      cases uses' <;> cases owned' <;> cases locality' <;>
+      first | rfl | exact Bool.noConfusion h
+
+namespace BinderContract
+
+/-- Usage convenience constructors preserve shared, unrestricted access. -/
+def erased : BinderContract := { uses := .erased }
+def linear : BinderContract := { uses := .linear }
+def affine : BinderContract := { uses := .affine }
+def many : BinderContract := {}
+
+def toBits (b : BinderContract) : UInt8 :=
+  b.uses.toBits ||| (b.value.toBits <<< 2)
+
+def ofBits? (bits : UInt8) : Option BinderContract := do
+  if bits > 15 then none else
+    return ⟨← Uses.ofBits? (bits &&& 3), ← ValueContract.ofBits? (bits >>> 2)⟩
+
+@[simp] theorem ofBits?_toBits (b : BinderContract) :
+    ofBits? b.toBits = some b := by
+  rcases b with ⟨uses, owned, locality⟩
+  cases uses <;> cases owned <;> cases locality <;> rfl
+
+end BinderContract
+
+def packAllContract (input : BinderContract) (result : ValueContract) : UInt8 :=
+  input.toBits ||| (result.toBits <<< 4)
+
+def unpackAllContract? (bits : UInt8) : Option (BinderContract × ValueContract) := do
+  if bits > 63 then none else
+    return (← BinderContract.ofBits? (bits &&& 15),
+      ← ValueContract.ofBits? (bits >>> 4))
+
+@[simp] theorem unpackAllContract?_packAllContract
+    (input : BinderContract) (result : ValueContract) :
+    unpackAllContract? (packAllContract input result) = some (input, result) := by
+  rcases input with ⟨uses, owned, locality⟩
+  rcases result with ⟨resultOwned, resultLocality⟩
+  cases uses <;> cases owned <;> cases locality <;>
+    cases resultOwned <;> cases resultLocality <;> rfl
+
+inductive LetKind where
+  | value
+  | borrowShared
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable
+
+instance : ReflBEq LetKind where
+  rfl := by intro k; cases k <;> rfl
+
+instance : LawfulBEq LetKind where
+  eq_of_beq := by
+    intro k k' h
+    cases k <;> cases k' <;> first | rfl | exact Bool.noConfusion h
+
+structure LetContract where
+  nonDep : Bool
+  kind : LetKind := .value
+  binder : BinderContract := .many
+  deriving BEq, DecidableEq, Repr, Inhabited, Hashable
+
+namespace LetContract
+
+def lean (nonDep : Bool) : LetContract := { nonDep }
+
+def borrow (nonDep : Bool) (uses : Uses := .many) : LetContract :=
+  { nonDep, kind := .borrowShared, binder := ⟨uses, .localShared⟩ }
+
+/-- The existing let Tag4 size holds the dependency and borrow-kind flags. -/
+def flags (c : LetContract) : UInt64 :=
+  (if c.nonDep then 1 else 0) ||| (match c.kind with | .value => 0 | .borrowShared => 2)
+
+def ofFlags? (flags : UInt64) (binder : BinderContract) : Option LetContract :=
+  if flags > 3 then none else
+    some {
+      nonDep := flags &&& 1 == 1
+      kind := if flags &&& 2 == 2 then .borrowShared else .value
+      binder := binder
+    }
+
+@[simp] theorem ofFlags?_flags (c : LetContract) :
+    ofFlags? c.flags c.binder = some c := by
+  rcases c with ⟨nonDep, kind, binder⟩
+  cases nonDep <;> cases kind <;> simp [ofFlags?, flags] <;> decide
+
+end LetContract
+
+namespace Uses
+
+/-- Alternative paths join their possible demands. -/
+def join : Uses → Uses → Uses
+  | .erased, .erased => .erased
+  | .linear, .linear => .linear
+  | .many, _ | _, .many => .many
+  | _, _ => .affine
+
+def admits : Uses → Nat → Prop
+  | .erased, n => n = 0
+  | .linear, n => n = 1
+  | .affine, n => n ≤ 1
+  | .many, _ => True
+
+theorem covers_sound (declared actual : Uses) (n : Nat)
+    (h : declared.covers actual = true) (hn : actual.admits n) :
+    declared.admits n := by
+  cases declared <;> cases actual <;> simp_all [covers, admits]
+
+theorem join_left (a b : Uses) (n : Nat) (h : a.admits n) :
+    (a.join b).admits n := by
+  cases a <;> cases b <;> simp_all [join, admits]
+
+theorem join_right (a b : Uses) (n : Nat) (h : b.admits n) :
+    (a.join b).admits n := by
+  cases a <;> cases b <;> simp_all [join, admits]
+
+theorem add_sound (a b : Uses) (m n : Nat)
+    (ha : a.admits m) (hb : b.admits n) : (add a b).admits (m + n) := by
+  cases a <;> cases b <;> simp_all [add, admits]
+
+theorem mul_sound (a b : Uses) (m n : Nat)
+    (ha : a.admits m) (hb : b.admits n) : (mul a b).admits (m * n) := by
+  cases a <;> cases b <;> simp_all [mul, admits]
+  simpa using Nat.mul_le_mul ha hb
+
+end Uses
+end Ixon
+end
diff --git a/Ix/IxonMode.lean b/Ix/IxonMode.lean
index 407876b0e..045a48453 100644
--- a/Ix/IxonMode.lean
+++ b/Ix/IxonMode.lean
@@ -4,12 +4,12 @@ public import Ix.Common
 /-!
 # Ixon binder modes
 
-Ixon v2 carries substructural intent directly on binder nodes.  Ordinary
+Ixon v3 carries independent usage, ownership, and locality contracts. Ordinary
 Lean compilation inhabits the conservative fragment: every lambda/forall
 binder is `.many`, and every forall result is `.shared`.
 -/
 
-public section
+@[expose] public section
 
 namespace Ixon
 
@@ -75,7 +75,7 @@ def ofBits? : UInt8 → Option Uses
 
 end Uses
 
-/-- Ownership available to the caller for a forall result. -/
+/-- Ownership of a bound or returned value, independent of usage and locality. -/
 inductive Owned where
   | unique
   | shared
diff --git a/Ix/IxonSyntax/AST.lean b/Ix/IxonSyntax/AST.lean
index 41c14e361..909da4941 100644
--- a/Ix/IxonSyntax/AST.lean
+++ b/Ix/IxonSyntax/AST.lean
@@ -15,16 +15,15 @@
 module
 
 public import Lean.Expr
+public import Ix.IxonContract
 
 public section
 
 namespace Ixon.Syntax
 
-/-- Grammar version this implementation speaks . The `ixon <n>`
-    header is optional: absent means version 1, forever; grammar
-    versions ≥ 2 must declare themselves, and canonical version-1
-    output omits the header. Mirrors Rust `syntax::VERSION`. -/
-def VERSION : Nat := 1
+/-- Current grammar. Whole files require `ixon 3`; standalone terms use
+the current grammar directly. -/
+def VERSION : Nat := 3
 
 /-- Parser resource caps . Mirrors Rust
     `syntax::Limits`, including the defaults. -/
@@ -120,11 +119,11 @@ inductive Term where
       printer flattens nested spines. -/
   | app (head : Term) (args : Array Term) (span : Span)
   | lam (binders : Array BinderGroup) (body : Term) (span : Span)
-  | pi (binders : Array BinderGroup) (body : Term) (span : Span)
-  | arrow (dom cod : Term) (span : Span)
+  | pi (binders : Array BinderGroup) (result : Ixon.ValueContract) (body : Term) (span : Span)
+  | arrow (result : Ixon.ValueContract) (dom cod : Term) (span : Span)
   /-- `let` (`nonDep = false`) / `have` (`nonDep = true`) —
       address-relevant. -/
-  | letE (nonDep : Bool) (name : BinderName) (ty val body : Term)
+  | letE (contract : Ixon.LetContract) (name : BinderName) (ty val body : Term)
       (span : Span)
   | natLit (n : Nat) (span : Span)
   | strLit (s : String) (span : Span)
@@ -134,7 +133,7 @@ inductive Term where
     metadata only, never address-relevant. Unnamed instance `[T]` has
     empty `names`. -/
 inductive BinderGroup where
-  | mk (info : Lean.BinderInfo) (names : Array BinderName) (ty : Term)
+  | mk (contract : Ixon.BinderContract) (info : Lean.BinderInfo) (names : Array BinderName) (ty : Term)
       (span : Span)
 
 end
@@ -142,24 +141,27 @@ end
 instance : Inhabited Term := ⟨.sort .prop {}⟩
 
 instance : Inhabited BinderGroup :=
-  ⟨.mk .default #[] (.sort .prop {}) {}⟩
+  ⟨.mk .many .default #[] (.sort .prop {}) {}⟩
+
+def BinderGroup.contract : BinderGroup → Ixon.BinderContract
+  | .mk c _ _ _ _ => c
 
 def BinderGroup.info : BinderGroup → Lean.BinderInfo
-  | .mk i _ _ _ => i
+  | .mk _ i _ _ _ => i
 
 def BinderGroup.names : BinderGroup → Array BinderName
-  | .mk _ n _ _ => n
+  | .mk _ _ n _ _ => n
 
 def BinderGroup.ty : BinderGroup → Term
-  | .mk _ _ t _ => t
+  | .mk _ _ _ t _ => t
 
 def BinderGroup.span : BinderGroup → Span
-  | .mk _ _ _ s => s
+  | .mk _ _ _ _ s => s
 
 def Term.span : Term → Span
   | .ref r => r.span
   | .sort _ s | .natLit _ s | .strLit _ s => s
-  | .app _ _ s | .lam _ _ s | .pi _ _ s | .arrow _ _ s
+  | .app _ _ s | .lam _ _ s | .pi _ _ _ s | .arrow _ _ _ s
   | .letE _ _ _ _ _ s | .proj _ _ _ s => s
 
 /-- `def` / `theorem` / `opaque` — address-relevant. -/
@@ -343,10 +345,10 @@ partial def countTermNodes : Term → Nat
     | _ => 1
   | .app h args _ =>
     args.foldl (fun acc a => acc + countTermNodes a) (1 + countTermNodes h)
-  | .lam bs body _ | .pi bs body _ =>
+  | .lam bs body _ | .pi bs _ body _ =>
     bs.foldl (fun acc b => acc + 1 + countTermNodes b.ty)
       (1 + countTermNodes body)
-  | .arrow d c _ => 1 + countTermNodes d + countTermNodes c
+  | .arrow _ d c _ => 1 + countTermNodes d + countTermNodes c
   | .letE _ _ t v b _ =>
     1 + countTermNodes t + countTermNodes v + countTermNodes b
   | .natLit .. | .strLit .. => 1
diff --git a/Ix/IxonSyntax/Parser.lean b/Ix/IxonSyntax/Parser.lean
index d0a7c4f9d..70bd34f4a 100644
--- a/Ix/IxonSyntax/Parser.lean
+++ b/Ix/IxonSyntax/Parser.lean
@@ -33,7 +33,7 @@ namespace Parser
 def RESERVED : List String :=
   [ "import", "def", "theorem", "opaque", "axiom", "quot", "inductive",
     "recursor", "mutual", "end", "unsafe", "partial", "fun", "let",
-    "have", "where", "proj", "Prop", "Type", "Sort", "dprj", "iprj",
+    "have", "borrow", "where", "proj", "Prop", "Type", "Sort", "dprj", "iprj",
     "cprj", "rprj" ]
 
 def isReserved (s : String) : Bool := RESERVED.contains s
@@ -746,6 +746,44 @@ partial def appP : M Term := do
   if args.isEmpty then return head
   else return .app head args (head.span.to args.back!.span)
 
+
+/-- Compact independent mode prefixes. Repeating an axis is invalid. -/
+partial def contractPrefix (allowUsage : Bool) : M Ixon.BinderContract := do
+  ws
+  let ctx ← read
+  let start ← curIdx
+  let mut i := start
+  let mut uses : Ixon.Uses := .many
+  let mut usageSeen := false
+  let mut unique := false
+  let mut localSeen := false
+  let mut go := true
+  while go do
+    match ctx.chars[i]? with
+    | some '!' =>
+      if unique then return ← failExp i "one ownership prefix"
+      unique := true
+      i := i + 1
+    | some '~' =>
+      if localSeen then return ← failExp i "one locality prefix"
+      localSeen := true
+      i := i + 1
+    | some c =>
+      if allowUsage && (c == '0' || c == '1' || c == '&') then
+        if usageSeen then return ← failExp i "one usage prefix"
+        usageSeen := true
+        uses := if c == '0' then .erased else if c == '1' then .linear else .affine
+        i := i + 1
+      else go := false
+    | none => go := false
+  setIdx i
+  if i != start then
+    ws
+    if (← curIdx) == i then return ← failExp i "space after contract prefix"
+  return { uses, value := {
+    owned := if unique then .unique else .shared
+    locality := if localSeen then .local else .unrestricted } }
+
 /-- One bracketed binder group. `(…)` is tentative (backtrackable
     before the `:`); `{…}`, `[…]`, `⦃…⦄` commit. -/
 partial def binderGroup : M BinderGroup := do
@@ -763,23 +801,24 @@ partial def binderGroup : M BinderGroup := do
   | none => failExp start "binder"
   | some (openC, closeS, info) => do
     setIdx (start + 1)
+    let contract ← contractPrefix true
     if openC == '[' then do
       match ← attempt? binderNamesColon with
       | some names => do
         let ty ← cut term
         let _ ← cut (sym closeS)
-        return .mk info names ty (← sp start (← curIdx))
+        return .mk contract info names ty (← sp start (← curIdx))
       | none => do
         let ty ← cut term
         let _ ← cut (sym closeS)
-        return .mk info #[] ty (← sp start (← curIdx))
+        return .mk contract info #[] ty (← sp start (← curIdx))
     else do
       let names ←
         if openC == '(' then binderNamesColon
         else cut binderNamesColon
       let ty ← cut term
       let _ ← cut (sym closeS)
-      return .mk info names ty (← sp start (← curIdx))
+      return .mk contract info names ty (← sp start (← curIdx))
 
 /-- `ident+ :` — the committing prefix of a named binder group. -/
 partial def binderNamesColon : M (Array BinderName) := do
@@ -814,14 +853,27 @@ partial def lamTerm : M Term := do
 /-- `let x : T := v; b` / `have x : T := v; b`. -/
 partial def letTerm (nonDep : Bool) : M Term := do
   let ksp ← kw (if nonDep then "have" else "let")
-  let name ← cut binderNameP
-  let _ ← cut (sym ":")
-  let ty ← cut term
+  let kind ← if (← peekWord) == some "borrow" then do
+      let _ ← kw "borrow"
+      pure Ixon.LetKind.borrowShared
+    else pure Ixon.LetKind.value
+  ws
+  let ctx ← read
+  let (name, ty, binder) ← if ctx.chars[(← curIdx)]? == some '(' then do
+      let group ← cut binderGroup
+      if group.info != .default || group.names.size != 1 then
+        cut (failExp (← curIdx) "one explicit let binder")
+      else pure (group.names[0]!, group.ty, group.contract)
+    else do
+      let name ← cut binderNameP
+      let _ ← cut (sym ":")
+      let ty ← cut term
+      pure (name, ty, Ixon.BinderContract.many)
   let _ ← cut (sym ":=")
   let val ← cut term
   let _ ← cut (sym ";")
   let body ← cut term
-  return .letE nonDep name ty val body (ksp.to body.span)
+  return .letE { nonDep, kind, binder } name ty val body (ksp.to body.span)
 
 /-- Dependent domain: `binder+ → term` (committed once the first
     group parses). -/
@@ -830,8 +882,9 @@ partial def piTerm : M Term := do
   let start ← curIdx
   let groups ← binderGroups1
   let _ ← cut arrowTok
+  let output ← cut (contractPrefix false)
   let body ← cut term
-  return .pi groups body ⟨← off start, body.span.stop⟩
+  return .pi groups output.value body ⟨← off start, body.span.stop⟩
 
 /-- Arrow layer: dependent domain, or application with optional `→`. -/
 partial def piOrArrow : M Term := do
@@ -851,8 +904,9 @@ partial def appArrow : M Term := do
   let lhs ← appP
   match ← attempt? arrowTok with
   | some _ => do
+    let output ← cut (contractPrefix false)
     let cod ← cut term
-    return .arrow lhs cod (lhs.span.to cod.span)
+    return .arrow output.value lhs cod (lhs.span.to cod.span)
   | none => return lhs
 
 /-- Term entry point. -/
@@ -1217,26 +1271,11 @@ partial def mainExprP : M MainExpr := do
 partial def file : M File := do
   ws
   let startIdx ← curIdx
-  -- Optional version header: absent means version 1, forever
-  -- (grammar versions ≥ 2 must declare themselves). A leading `ixon`
-  -- followed by a numeral is always the header (a constant literally
-  -- named `ixon` applied to a literal at file start needs parens);
-  -- followed by anything else it is content.
-  let version ←
-    if (← peekWord) == some "ixon" then do
-      let saved ← get
-      let _ ← kw "ixon"
-      ws
-      let ctx ← read
-      if (ctx.chars[(← curIdx)]?).any Char.isDigit then do
-        let (version, vsp) ← natU64
-        if version != VERSION then
-          failFatal (.unknownVersion version VERSION) vsp
-        else pure version
-      else do
-        set saved
-        pure VERSION
-    else pure VERSION
+  let _ ← cut (kw "ixon")
+  let (version, vsp) ← cut natU64
+  if version != VERSION then
+    failFatal (.unknownVersion version VERSION) vsp
+  else pure ()
   do
     let mut imports := #[]
     let mut go := true
diff --git a/Ix/IxonSyntax/Print.lean b/Ix/IxonSyntax/Print.lean
index 315be8f33..bb918e073 100644
--- a/Ix/IxonSyntax/Print.lean
+++ b/Ix/IxonSyntax/Print.lean
@@ -202,6 +202,15 @@ def binderNameStr : BinderName → String
   | .ident c _ => componentStr c
   | .anon _ => "_"
 
+def valuePrefix (value : Ixon.ValueContract) : String :=
+  (if value.locality == .local then "~" else "") ++
+    (if value.owned == .unique then "!" else "")
+
+def binderPrefix (contract : Ixon.BinderContract) : String :=
+  let prefixText := valuePrefix contract.value ++ (match contract.uses with
+    | .erased => "0" | .linear => "1" | .affine => "&" | .many => "")
+  if prefixText.isEmpty then "" else prefixText ++ " "
+
 mutual
 
 partial def termDoc (t : Term) (minPrec : Nat) : Doc :=
@@ -243,25 +252,41 @@ partial def termDocBare : Term → Doc
     ds := ds.push (text " =>")
     ds := ds.push (group (nest (cat #[line, termDoc body 0])))
     return cat ds
-  | .pi binders body _ => Id.run do
+  | .pi binders result body _ => Id.run do
     let mut ds := #[]
     for b in binders do
       ds := ds.push (binderDoc b)
       ds := ds.push (text " ")
     ds := ds.push (text "→")
-    ds := ds.push (group (nest (cat #[line, termDoc body 1])))
+    ds := ds.push (group (nest (cat #[line, resultDoc result body])))
     return cat ds
-  | .arrow dom cod _ =>
+  | .arrow result dom cod _ =>
     cat #[termDoc dom 2, text " →",
-      group (nest (cat #[line, termDoc cod 1]))]
-  | .letE nonDep name ty val body _ =>
-    let kwS := if nonDep then "have" else "let"
-    cat #[text s!"{kwS} {binderNameStr name} : ", termDoc ty 0,
-      text " :=", group (nest (cat #[line, termDoc val 0])), text ";",
-      hard, termDoc body 0]
+      group (nest (cat #[line, resultDoc result cod]))]
+  | .letE contract name ty val body _ =>
+    let kwS := if contract.nonDep then "have" else "let"
+    let borrow := if contract.kind == .borrowShared then " borrow" else ""
+    let annotated := contract.kind != .value || contract.binder != .many
+    let openS := if annotated then "(" else ""
+    let closeS := if annotated then ")" else ""
+    cat #[text s!"{kwS}{borrow} {openS}{binderPrefix contract.binder}{binderNameStr name} : ",
+      termDoc ty 0, text s!"{closeS} :=",
+      group (nest (cat #[line, termDoc val 0])), text ";", hard, termDoc body 0]
   | .proj typeRef idx val _ =>
     cat #[text s!"proj {crefStr typeRef} {idx} ", termDoc val 3]
 
+partial def resultDoc (result : Ixon.ValueContract) (term : Term) : Doc :=
+  let prefixText := valuePrefix result
+  if prefixText.isEmpty then termDoc term 1
+  else cat #[text (prefixText ++ " "), termDoc term 1]
+
+/-- Numeric unnamed types need parentheses to distinguish usage prefixes. -/
+partial def numericHead : Term → Bool
+  | .natLit .. => true
+  | .app head _ _ => numericHead head
+  | .arrow _ dom _ _ => numericHead dom
+  | _ => false
+
 partial def binderDoc (b : BinderGroup) : Doc :=
   let (openS, closeS) := match b.info with
     | .default => ("(", ")")
@@ -269,11 +294,14 @@ partial def binderDoc (b : BinderGroup) : Doc :=
     | .strictImplicit => ("⦃", "⦄")
     | .instImplicit => ("[", "]")
   let inner :=
-    if b.names.isEmpty then #[termDoc b.ty 0]
+    if b.names.isEmpty then
+      if b.contract == Ixon.BinderContract.many && numericHead b.ty then
+        #[text "(", termDoc b.ty 0, text ")"]
+      else #[termDoc b.ty 0]
     else
       #[text (" ".intercalate (b.names.toList.map binderNameStr) ++ " : "),
         termDoc b.ty 0]
-  group (cat (#[text openS] ++ inner ++ #[text closeS]))
+  group (cat (#[text openS, text (binderPrefix b.contract)] ++ inner ++ #[text closeS]))
 
 end
 
@@ -382,15 +410,13 @@ def printDecl (d : Decl) : String :=
 
 /-- Print a whole file in canonical form: sections (imports block,
     declarations, optional trailing main expression) separated by
-    blank lines, trailing newline. The version header is emitted only
-    for versions ≥ 2 — absent means version 1, forever. The main
+    blank lines, trailing newline. The version header is always emitted. The main
     expression's value prints at precedence 2 — `fun`/`let`/arrows
     parenthesize, so `⊢ (fun (x : A) => x) : A → A` rather than the
     visually ambiguous bare form (both reparse identically). -/
 def printFile (f : File) : String := Id.run do
   let mut sections : Array String := #[]
-  if f.version != 1 then
-    sections := sections.push s!"ixon {f.version}"
+  sections := sections.push s!"ixon {f.version}"
   if !f.imports.isEmpty then
     sections := sections.push
       ("\n".intercalate (f.imports.toList.map Print.importStr))
diff --git a/Ix/MultiStark/Aggregate.lean b/Ix/MultiStark/Aggregate.lean
index 23c46119a..d9e061248 100644
--- a/Ix/MultiStark/Aggregate.lean
+++ b/Ix/MultiStark/Aggregate.lean
@@ -483,6 +483,10 @@ def aggregate := ⟦
   fn join_parse_check_env(bytes: ByteStream) -> (Addr, Option‹Addr›) {
     let (tag, s) = join_read_byte(bytes);
     assert_eq!(tag, 0xE5u8, "join: child claim is not CheckEnv");
+    let (format, s) = join_read_byte(s);
+    assert_eq!(format, 3u8, "join: unsupported object format");
+    let (validator, s) = join_read_byte(s);
+    assert_eq!(validator, 1u8, "join: wrong validator identity");
     let (root, s2) = join_read_address(s);
     let (assumptions, stop) = join_get_opt_address(s2);
     assert_eq!(load(stop), ListNode.Nil,
@@ -740,3 +744,4 @@ def aggregate := ⟦
 end MultiStark
 
 end
+
diff --git a/Ix/Resource/Addressed.lean b/Ix/Resource/Addressed.lean
new file mode 100644
index 000000000..8060d3cbc
--- /dev/null
+++ b/Ix/Resource/Addressed.lean
@@ -0,0 +1,379 @@
+module
+
+public import Ix.Resource.Admit
+
+/-!
+# Addressed resource interfaces
+
+This boundary reads canonical bytes and ignores presentation metadata. It
+resolves each constant's local tables to one program, derives nominal kinds
+and supported projection fields, and binds every external rule to an explicit
+profile address. Resource admission still requires a separate erased typing
+check of these same bytes; `prepare` is deliberately not a certificate.
+-/
+
+@[expose] public section
+
+namespace Ix.Resource
+
+open Ixon
+
+def validatorId : String := "ixon-v3/resource-v1"
+
+structure Profile where
+  assumptions : Array Address := #[]
+  shareableTypes : Array Address := #[]
+  choices : Array Address := #[]
+  natType : Option Address := none
+  stringType : Option Address := none
+  limits : Limits := {}
+  deriving Inhabited, Repr
+
+def Profile.validate (profile : Profile) : Except String Unit := do
+  for addresses in #[profile.assumptions, profile.shareableTypes, profile.choices] do
+    let mut previous : Option Address := none
+    for address in addresses do
+      if address.hash.size != 32 then throw "resource profile: invalid address length"
+      if let some before := previous then
+        unless Address.cmpBytes before address == .lt do
+          throw "resource profile: address lists must be strictly increasing"
+      previous := some address
+  for address in #[profile.natType, profile.stringType] do
+    if let some address := address then
+      if address.hash.size != 32 then throw "resource profile: invalid literal type address"
+  for choice in profile.choices do
+    unless profile.assumptions.contains choice do
+      throw "resource profile: selection primitive must be an explicit assumption"
+  if profile.limits.depth == 0 || profile.limits.steps == 0 ||
+      profile.limits.depth >= UInt64.size || profile.limits.steps >= UInt64.size then
+    throw "resource profile: invalid checker limits"
+
+/-- Canonical, domain-separated profile bytes, including the checker limits.
+Lists are validated before these bytes are used as a commitment. -/
+def Profile.bytes (profile : Profile) : ByteArray :=
+  (validatorId ++ "/profile\x00").toUTF8 ++ runPut do
+    for addresses in #[profile.assumptions, profile.shareableTypes, profile.choices] do
+      putTag0 ⟨addresses.size.toUInt64⟩
+      for address in addresses do Serialize.put address
+    for address in #[profile.natType, profile.stringType] do
+      match address with
+      | none => putU8 0
+      | some address => putU8 1; Serialize.put address
+    putTag0 ⟨profile.limits.depth.toUInt64⟩
+    putTag0 ⟨profile.limits.steps.toUInt64⟩
+
+def Profile.address (profile : Profile) : Except String Address := do
+  profile.validate
+  return Address.blake3 profile.bytes
+
+def Profile.ofBytes (bytes : ByteArray) : Except String Profile := do
+  let profile : Profile ← runGetExact (do
+    let header := (validatorId ++ "/profile\x00").toUTF8
+    unless (← getBytes header.size) == header do throw "resource profile: wrong validator identifier"
+    let list : GetM (Array Address) := do
+      let count := (← getTag0).size.toNat
+      let state ← get
+      if count > (state.bytes.size - state.idx) / 32 then throw "resource profile: impossible address count"
+      let mut result := #[]
+      for _ in [:count] do result := result.push (← Serialize.get)
+      return result
+    let optional : GetM (Option Address) := do
+      match (← getU8) with
+      | 0 => pure none
+      | 1 => some <$> Serialize.get
+      | _ => throw "resource profile: invalid optional address tag"
+    let assumptions ← list
+    let shareableTypes ← list
+    let choices ← list
+    let natType ← optional
+    let stringType ← optional
+    let depth := (← getTag0).size.toNat
+    let steps := (← getTag0).size.toNat
+    return { assumptions, shareableTypes, choices, natType, stringType, limits := { depth, steps } }) bytes
+  profile.validate
+  return profile
+
+structure AddressedProgram where
+  program : Program
+  policy : Policy
+  addresses : Array Address
+  profileAddress : Address
+  deriving Inhabited
+
+namespace Addressed
+
+structure Pending where
+  address : Address
+  constant : Constant
+  members : Array Address
+  declaration : Declaration
+  auxiliary : Array Ixon.Expr := #[]
+  deriving Inhabited
+
+def wrapper (info : Ixon.ConstantInfo) : Constant := ⟨info, #[], #[], #[]⟩
+
+def commit (constant : Constant) : Address := Address.blake3 (serConstant constant)
+
+def memberWrapper (block : Address) (index : UInt64) : MutConst → Constant
+  | .defn _ => wrapper (.dPrj ⟨index, block⟩)
+  | .indc _ => wrapper (.iPrj ⟨index, block⟩)
+  | .recr _ => wrapper (.rPrj ⟨index, block⟩)
+
+def constructorWrapper (block : Address) (index ctor : UInt64) : Constant :=
+  wrapper (.cPrj ⟨index, ctor, block⟩)
+
+def definition (d : Definition) : Declaration := {
+  type := d.typ, body := some d.value
+  kind := if d.safety == .safe then .definition else .assumption }
+
+def recursor (d : Recursor) : Declaration := {
+  type := d.typ, kind := .assumption }
+
+def requireWrapper (constants : Std.HashMap Address Constant) (expected : Constant) :
+    Except String Address := do
+  let address := commit expected
+  let some actual := constants[address]?
+    | throw s!"resource adapter: missing canonical projection {address}"
+  unless actual == expected do throw s!"resource adapter: invalid projection wrapper {address}"
+  return address
+
+def index (indices : Std.HashMap Address UInt64) (address : Address) : Except String UInt64 :=
+  match indices[address]? with
+  | some i => .ok i
+  | none => .error s!"resource adapter: missing typed interface {address}"
+
+structure Tables where
+  refs : Array Address
+  members : Array Address
+  indices : Std.HashMap Address UInt64
+  kinds : Array DeclKind
+  blobs : Std.HashMap Address UInt64
+  univCount : Nat
+  shareCount : Nat
+  shareOffset : Nat
+  deriving Inhabited
+
+def checkedUInt (n : Nat) : Except String UInt64 :=
+  if n < UInt64.size then .ok n.toUInt64
+  else .error "resource adapter: index overflow"
+
+def Tables.reference (tables : Tables) (i : UInt64) : Except String Address :=
+  match tables.refs[i.toNat]? with
+  | some a => .ok a
+  | none => .error "resource adapter: reference index out of bounds"
+
+def Tables.universes (tables : Tables) (levels : Array UInt64) : Except String Unit := do
+  for level in levels do
+    if level.toNat >= tables.univCount then throw "resource adapter: universe index out of bounds"
+
+/-- Resolve every local reference namespace, including blob identities. The
+global sharing table still contains open expressions; analysis expands them
+in the context of each use. This remapping has no contextual validity cache. -/
+def remap (tables : Tables) : Nat → Ixon.Expr → Except String Ixon.Expr
+  | 0, _ => .error "resource adapter: expression depth exceeded"
+  | fuel + 1, e => do
+    match e with
+    | .var _ => return e
+    | .sort level =>
+      if level.toNat >= tables.univCount then throw "resource adapter: universe index out of bounds"
+      return e
+    | .ref i levels =>
+      tables.universes levels
+      return .ref (← index tables.indices (← tables.reference i)) levels
+    | .recur i levels =>
+      tables.universes levels
+      let some address := tables.members[i.toNat]?
+        | throw "resource adapter: recursive index out of bounds"
+      return .ref (← index tables.indices address) levels
+    | .nat i | .str i =>
+      let address ← tables.reference i
+      let some id := tables.blobs[address]?
+        | throw s!"resource adapter: missing literal blob {address}"
+      match e with
+      | .nat _ => return .nat id
+      | _ => return .str id
+    | .share i =>
+      if i.toNat >= tables.shareCount then throw "resource adapter: sharing index out of bounds"
+      return .share (← checkedUInt (tables.shareOffset + i.toNat))
+    | .prj i field value =>
+      let typeId ← index tables.indices (← tables.reference i)
+      unless tables.kinds[typeId.toNat]? == some .typeConstructor do
+        throw "resource adapter: projection owner is not an inductive type"
+      return .prj typeId field (← remap tables fuel value)
+    | .app fn arg => return .app (← remap tables fuel fn) (← remap tables fuel arg)
+    | .lam c type body => return .lam c (← remap tables fuel type) (← remap tables fuel body)
+    | .all c r type body => return .all c r (← remap tables fuel type) (← remap tables fuel body)
+    | .letE c type value body =>
+      return .letE c (← remap tables fuel type) (← remap tables fuel value) (← remap tables fuel body)
+
+def closed (program : Program) : Nat → Nat → Ixon.Expr → CheckM Bool
+  | 0, _, _ => throw .budget
+  | fuel + 1, depth, e => do
+    tick
+    match e with
+    | .var i => return i.toNat < depth
+    | .share i => closed program fuel depth (← expansion program i)
+    | .recur .. => return false
+    | .app f a => return (← closed program fuel depth f) && (← closed program fuel depth a)
+    | .lam _ t b | .all _ _ t b =>
+      return (← closed program fuel depth t) && (← closed program fuel (depth + 1) b)
+    | .letE _ t v b =>
+      return (← closed program fuel depth t) && (← closed program fuel depth v) &&
+        (← closed program fuel (depth + 1) b)
+    | .prj _ _ v => closed program fuel depth v
+    | _ => return true
+
+/-- Initial transparent projection rule: a single constructor with no
+parameters/indices, closed field types, and unrestricted field quantities.
+Finite-use and dependent fields require a richer elimination rule. Omitting
+a rule makes every attempted resource projection fail closed. -/
+def fields (program : Program) (limits : Limits) (typeId ctorId : UInt64) (count : Nat) :
+    Except Error (Array Field) := runCheck limits do
+  let mut type := (← declaration program ctorId).type
+  let mut fields := #[]
+  for i in [:count] do
+    type ← whnf program limits.depth type
+    let .all input _ domain body := type | throw (.unsupported "constructor field telescope")
+    unless input.uses == .many && (← closed program limits.depth 0 domain) do
+      throw (.unsupported "dependent or finite-use projection field")
+    fields := fields.push { typeRef := typeId, index := i.toUInt64, type := domain, contract := input.value }
+    type := body
+  return fields
+
+def prepare (env : Ixon.Env) (profile : Profile := {}) : Except String AddressedProgram := do
+  let profileAddress ← profile.address
+  let entries := env.consts.toArray.qsort fun a b => Address.cmpBytes a.1 b.1 == .lt
+  let mut constants : Std.HashMap Address Constant := {}
+  for (address, lazy) in entries do
+    if address.hash.size != 32 then throw "resource adapter: invalid constant address"
+    let raw := lazy.rawBytes
+    unless Address.blake3 raw == address do throw s!"resource adapter: constant hash mismatch {address}"
+    -- Parse the bounded raw bytes even if a caller supplied a materialized cache.
+    let constant ← (runGetExact getConstant raw).mapError fun e => s!"resource adapter: {address}: {e}"
+    unless serConstant constant == raw do throw s!"resource adapter: noncanonical constant {address}"
+    constants := constants.insert address constant
+  let mut pending : Array Pending := #[]
+  let mut groups : Array (Array Address) := #[]
+  let mut fieldSpecs : Array (Address × Address × Nat) := #[]
+  for (address, _) in entries do
+    let constant := constants[address]!
+    match constant.info with
+    | .defn d =>
+      pending := pending.push ⟨address, constant, #[address], definition d, #[]⟩
+    | .recr r =>
+      pending := pending.push ⟨address, constant, #[address], recursor r, r.rules.map (·.rhs)⟩
+    | .axio a =>
+      pending := pending.push ⟨address, constant, #[], { type := a.typ, kind := .assumption }, #[]⟩
+    | .quot q =>
+      pending := pending.push ⟨address, constant, #[], { type := q.typ, kind := .assumption }, #[]⟩
+    | .muts members =>
+      if members.isEmpty then throw "resource adapter: empty mutual block"
+      let mut addresses := #[]
+      for i in [:members.size] do
+        addresses := addresses.push (← requireWrapper constants (memberWrapper address i.toUInt64 members[i]!))
+      let mut group := addresses
+      for i in [:members.size] do
+        let member := addresses[i]!
+        match members[i]! with
+        | .defn d =>
+          pending := pending.push ⟨member, constant, addresses, definition d, #[]⟩
+        | .recr r =>
+          pending := pending.push ⟨member, constant, addresses, recursor r, r.rules.map (·.rhs)⟩
+        | .indc ind =>
+          pending := pending.push ⟨member, constant, addresses,
+            { type := ind.typ, kind := .typeConstructor }, #[]⟩
+          for j in [:ind.ctors.size] do
+            let ctor := ind.ctors[j]!
+            let ctorAddr ← requireWrapper constants (constructorWrapper address i.toUInt64 j.toUInt64)
+            unless ctor.cidx.toNat == j && ctor.params == ind.params && ctor.lvls == ind.lvls do
+              throw "resource adapter: inconsistent constructor header"
+            pending := pending.push ⟨ctorAddr, constant, addresses,
+              { type := ctor.typ, kind := if ctor.isUnsafe then .assumption else .constructor }, #[]⟩
+            group := group.push ctorAddr
+            if !ind.isUnsafe && !ctor.isUnsafe && ind.params == 0 && ind.indices == 0 && ind.ctors.size == 1 then
+              fieldSpecs := fieldSpecs.push (member, ctorAddr, ctor.fields.toNat)
+          if ind.isUnsafe then
+            -- Unsafe nominal representations need an explicit profile assumption.
+            let k := pending.size - ind.ctors.size - 1
+            let p := pending[k]!
+            pending := pending.set! k { p with declaration := { p.declaration with kind := .assumption } }
+      groups := groups.push group
+    | _ => pure ()
+  pending := pending.qsort fun a b => Address.cmpBytes a.address b.address == .lt
+  let mut indices : Std.HashMap Address UInt64 := {}
+  let mut addresses := #[]
+  for i in [:pending.size] do
+    let address := pending[i]!.address
+    if indices.contains address then throw "resource adapter: duplicate resolved declaration"
+    indices := indices.insert address (← checkedUInt i)
+    addresses := addresses.push address
+  for (address, _) in entries do
+    match constants[address]!.info with
+    | .dPrj _ | .iPrj _ | .rPrj _ | .cPrj _ =>
+      unless indices.contains address do throw s!"resource adapter: invalid or orphan projection {address}"
+    | _ => pure ()
+  let mut blobs : Std.HashMap Address UInt64 := {}
+  for (address, bytes) in env.blobs.toArray.qsort (fun a b => Address.cmpBytes a.1 b.1 == .lt) do
+    unless address.hash.size == 32 && Address.blake3 bytes == address do
+      throw s!"resource adapter: blob hash mismatch {address}"
+    blobs := blobs.insert address (← checkedUInt blobs.size)
+  let kinds := pending.map (·.declaration.kind)
+  let mut program : Program := { declarations := #[] }
+  -- One remapped sharing table per distinct parent constant.
+  let mut offsets : Std.HashMap Address Nat := {}
+  for p in pending do
+    let parent := commit p.constant
+    let tables : Tables := {
+      refs := p.constant.refs, members := p.members, indices, kinds, blobs
+      univCount := p.constant.univs.size, shareCount := p.constant.sharing.size
+      shareOffset := offsets[parent]?.getD program.sharing.size }
+    if !offsets.contains parent then
+      offsets := offsets.insert parent tables.shareOffset
+      for expression in p.constant.sharing do
+        program := { program with sharing := program.sharing.push (← remap tables profile.limits.depth expression) }
+    let d := p.declaration
+    let type ← remap tables profile.limits.depth d.type
+    let body ← d.body.mapM (remap tables profile.limits.depth)
+    let i := program.declarations.size
+    program := { program with declarations := program.declarations.push { d with type, body } }
+    for expression in p.auxiliary do
+      program := { program with auxiliary := program.auxiliary.push (i, ← remap tables profile.limits.depth expression) }
+  for group in groups do
+    let group ← group.mapM fun a => return (← index indices a).toNat
+    program := { program with groups := program.groups.push group }
+  let resolveList := fun (list : Array Address) => list.mapM (index indices)
+  let assumptions ← resolveList profile.assumptions
+  let shareable ← resolveList profile.shareableTypes
+  let choices ← resolveList profile.choices
+  let literalType := fun (address : Address) => do
+    let i ← index indices address
+    unless kinds[i.toNat]? == some .typeConstructor do
+      throw "resource adapter: literal type must be a checked nominal type"
+    pure (Ixon.Expr.ref i #[])
+  program := { program with
+    natType := ← profile.natType.mapM literalType
+    stringType := ← profile.stringType.mapM literalType
+    shareableTypes := shareable, choices }
+  for (typeAddr, ctorAddr, count) in fieldSpecs do
+    if let .ok derived := fields program profile.limits (← index indices typeAddr) (← index indices ctorAddr) count then
+      program := { program with fields := program.fields ++ derived }
+  return {
+    program, addresses, profileAddress
+    policy := {
+      assumptions := assumptions.map UInt64.toNat
+      shareableTypes := shareable.map UInt64.toNat, choices := choices.map UInt64.toNat } }
+
+/-- Resource-only validation of addressed bytes. Erased typechecking and
+claim construction belong to the combined validator, not this helper. -/
+def checkResources (env : Ixon.Env) (profile : Profile := {}) : Except String AddressedProgram := do
+  let resolved ← prepare env profile
+  (admitProgram resolved.program resolved.policy profile.limits).mapError fun error =>
+    let location := error.declaration.bind fun i => resolved.addresses[i]?
+    s!"resource admission {location}: {repr error.error}"
+  return resolved
+
+end Addressed
+
+end Ix.Resource
+
+end
diff --git a/Ix/Resource/Admit.lean b/Ix/Resource/Admit.lean
new file mode 100644
index 000000000..5f0a16a83
--- /dev/null
+++ b/Ix/Resource/Admit.lean
@@ -0,0 +1,197 @@
+module
+
+public import Ix.Resource.Check
+
+/-!
+# Resource admission for a resolved program
+
+Ordinary components have no resource promise beyond shared, unrestricted,
+arbitrary-use access. They can use the ordinary typechecking path. A fixed
+point marks every declaration that contains, refers to, or shares a mutual
+block with a resource contract. Marked definitions are checked, marked
+external interfaces require an explicit profile assumption, and constructors
+must preserve their captures in every intermediate and final result.
+-/
+
+@[expose] public section
+
+namespace Ix.Resource
+
+open Ixon
+
+structure Scan where
+  annotated : Bool := false
+  dependencies : Array Nat := #[]
+  deriving Inhabited, Repr
+
+def Scan.merge (a b : Scan) : Scan :=
+  { annotated := a.annotated || b.annotated
+    dependencies := a.dependencies ++ b.dependencies }
+
+/-- Context-free reachability uses a DAG walk, not a tree expansion. The
+active set rejects sharing cycles; the finished set records only scanned
+syntax, never validity under a scope or ownership context. -/
+def scanExpr (program : Program) (fuel : Nat) (top : Ixon.Expr) : CheckM Scan := do
+  if fuel == 0 then throw .budget
+  let mut finished : Std.HashSet Ixon.Expr := {}
+  let mut active : Std.HashSet Ixon.Expr := {}
+  let mut stack := #[(top, false)]
+  let mut scan : Scan := {}
+  while !stack.isEmpty do
+    let (e, closing) := stack.back!
+    stack := stack.pop
+    if closing then
+      active := active.erase e
+      finished := finished.insert e
+      continue
+    if active.contains e then throw (.unsupported "cyclic sharing")
+    if finished.contains e then continue
+    tick
+    active := active.insert e
+    stack := stack.push (e, true)
+    match e with
+    | .ref index _ =>
+      let _ ← declaration program index
+      scan := { scan with dependencies := scan.dependencies.push index.toNat }
+    | .recur .. => throw (.unsupported "unresolved recursive reference")
+    | .share index => stack := stack.push (← expansion program index, false)
+    | .prj index _ value =>
+      let _ ← declaration program index
+      scan := { scan with dependencies := scan.dependencies.push index.toNat }
+      stack := stack.push (value, false)
+    | .app fn arg => stack := stack.push (arg, false) |>.push (fn, false)
+    | .lam input type body =>
+      scan := { scan with annotated := scan.annotated || input != .many }
+      stack := stack.push (body, false) |>.push (type, false)
+    | .all input result type body =>
+      scan := { scan with annotated := scan.annotated || input != .many || result != .shared }
+      stack := stack.push (body, false) |>.push (type, false)
+    | .letE contract type value body =>
+      scan := { scan with annotated := scan.annotated || contract.binder != .many || contract.kind != .value }
+      stack := stack.push (body, false) |>.push (value, false) |>.push (type, false)
+    | _ => pure ()
+  return scan
+
+def runCheck (limits : Limits) (action : CheckM α) : Except Error α :=
+  match action.run { remaining := limits.steps } with
+  | .ok result _ => .ok result
+  | .error error _ => .error error
+
+def relevance (program : Program) (limits : Limits := {}) : Except Error (Array Bool) := do
+  let size := program.declarations.size
+  let mut reverse : Array (Array Nat) := Array.replicate size #[]
+  let mut marked := Array.replicate size false
+  let mut queue := #[]
+  for i in [0:size] do
+    let d := program.declarations[i]!
+    let scan ← runCheck limits do
+      let type ← scanExpr program limits.depth d.type
+      match d.body with
+      | none => return type
+      | some value => return type.merge (← scanExpr program limits.depth value)
+    if scan.annotated then
+      marked := marked.set! i true
+      queue := queue.push i
+    for dependency in scan.dependencies do
+      if dependency >= size then throw (.badReference dependency)
+      reverse := reverse.set! dependency (reverse[dependency]!.push i)
+  for (i, expression) in program.auxiliary do
+    if i >= size then throw (.badReference i)
+    let scan ← runCheck limits (scanExpr program limits.depth expression)
+    if scan.annotated && !marked[i]! then
+      marked := marked.set! i true
+      queue := queue.push i
+    for dependency in scan.dependencies do
+      if dependency >= size then throw (.badReference dependency)
+      reverse := reverse.set! dependency (reverse[dependency]!.push i)
+  for field in program.fields do
+    let i := field.typeRef.toNat
+    if i >= size then throw (.badReference i)
+    if field.contract != .shared && !marked[i]! then
+      marked := marked.set! i true
+      queue := queue.push i
+  for group in program.groups do
+    if let some first := group[0]? then
+      if first >= size then throw (.badReference first)
+      for member in group do
+        if member >= size then throw (.badReference member)
+        reverse := reverse.set! first (reverse[first]!.push member)
+        reverse := reverse.set! member (reverse[member]!.push first)
+  let mut cursor := 0
+  while cursor < queue.size do
+    let i := queue[cursor]!
+    cursor := cursor + 1
+    for dependent in reverse[i]! do
+      if !marked[dependent]! then
+        marked := marked.set! dependent true
+        queue := queue.push dependent
+  return marked
+
+/-- Constructors retain runtime fields. Finite/unique captures require a
+unique result, and local captures require a local result. This applies to
+partial applications as well as the final aggregate. Type arguments and
+explicitly erased fields have no runtime capture. -/
+def checkConstructorType (program : Program) :
+    Nat → Ixon.Expr → Bool → Bool → CheckM Unit
+  | 0, _, _, _ => throw .budget
+  | fuel + 1, type, hasFinite, hasLocal => do
+    tick
+    let type ← whnf program fuel type
+    match type with
+    | .all input result domain codomain =>
+      let domain ← whnf program fuel domain
+      let erased := input.uses == .erased || (match domain with | .sort _ => true | _ => false)
+      if !input.uses.covers (if erased then .erased else .linear) then
+        throw (.unsupported "constructor input quantity does not cover its stored occurrence")
+      let finite := hasFinite || (!erased && (input.uses != .many || input.value.owned == .unique))
+      let localCapture := hasLocal || (!erased && input.value.locality == .local)
+      if finite && result.owned != .unique then
+        throw (.unsupported "constructor result drops a finite or unique capture")
+      if localCapture && result.locality != .local then
+        throw (.unsupported "constructor result drops a local capture")
+      checkConstructorType program fuel codomain finite localCapture
+    | _ => pure ()
+
+structure Policy where
+  /-- Resolved indices of externally admitted, addressed resource interfaces.
+  The address adapter obtains this list from the bound primitive profile. -/
+  assumptions : Array Nat := #[]
+  shareableTypes : Array Nat := #[]
+  choices : Array Nat := #[]
+  deriving Inhabited, Repr
+
+structure AdmissionError where
+  declaration : Option Nat
+  error : Error
+  deriving Repr
+
+def admitProgram (program : Program) (policy : Policy := {}) (limits : Limits := {}) :
+    Except AdmissionError Unit := do
+  for index in program.choices do
+    unless policy.choices.contains index.toNat && policy.assumptions.contains index.toNat do
+      throw ⟨some index.toNat, .unsupported "selection behavior is absent from the bound profile"⟩
+    let some d := program.declarations[index.toNat]?
+      | throw ⟨none, .badReference index.toNat⟩
+    unless d.kind == .assumption do
+      throw ⟨some index.toNat, .unsupported "selection behavior requires an external primitive interface"⟩
+  for index in program.shareableTypes do
+    unless policy.shareableTypes.contains index.toNat do
+      throw ⟨some index.toNat, .unsupported "shareable representation is absent from the bound profile"⟩
+  let marked ← (relevance program limits).mapError (⟨none, ·⟩)
+  for i in [0:program.declarations.size] do
+    if marked[i]! then
+      let d := program.declarations[i]!
+      let checked : Except Error Unit := match d.kind with
+        | .definition => checkDefinition program i limits
+        | .assumption =>
+          if policy.assumptions.contains i then .ok ()
+          else .error (.unsupported "external resource interface is absent from the bound profile")
+        | .constructor => runCheck limits (checkConstructorType program limits.depth d.type false false)
+        | .typeConstructor => .ok ()
+      checked.mapError (⟨some i, ·⟩)
+
+end Ix.Resource
+
+end
+
+
diff --git a/Ix/Resource/Audit.lean b/Ix/Resource/Audit.lean
new file mode 100644
index 000000000..f8ee00488
--- /dev/null
+++ b/Ix/Resource/Audit.lean
@@ -0,0 +1,28 @@
+import Ix.Tc.Verify.Audit.Basic
+import Ix.Resource.Admit
+
+/-! Exact trust manifest for the executable resource-state invariants.
+No native, upstream, pending, or sorry axioms are admitted. -/
+
+namespace Ix.Resource.Audit
+open Ix.Tc.Verify.Audit
+private def roots : Array RootAllowance := #[
+  { root := ``Ix.Resource.root_scopeTree, standardAxioms := #[``propext] },
+  { root := ``Ix.Resource.push_scopeTree, standardAxioms := #[``propext, ``Classical.choice, ``Quot.sound] },
+  { root := ``Ix.Resource.ancestor_older },
+  { root := ``Ix.Resource.outlivesAux_sound, standardAxioms := #[``propext, ``Quot.sound] },
+  { root := ``Ix.Resource.outlives_sound, standardAxioms := #[``propext, ``Quot.sound] },
+  { root := ``Ix.Resource.fresh_scope_cannot_escape, standardAxioms := #[``propext, ``Classical.choice, ``Quot.sound] },
+  { root := ``Ix.Resource.checkOrigins_sound, standardAxioms := #[``propext, ``Quot.sound] },
+  { root := ``Ix.Resource.endLoan_live },
+  { root := ``Ix.Resource.endLoan_unique },
+  { root := ``Ix.Resource.moveOwner_requires, standardAxioms := #[``propext] },
+  { root := ``Ix.Resource.shareOwner_permanent, standardAxioms := #[``propext] },
+  { root := ``Ix.Resource.checkUnrestricted_sound, standardAxioms := #[``propext] },
+  { root := ``Ix.Resource.joinOwner_live, standardAxioms := #[``propext] },
+  { root := ``Ix.Resource.joinOwner_unique, standardAxioms := #[``propext] },
+  { root := ``Ix.Resource.checkDemand_sound, standardAxioms := #[``propext, ``Quot.sound] }
+]
+run_cmd Ix.Tc.Verify.Audit.check roots
+end Ix.Resource.Audit
+
diff --git a/Ix/Resource/Basic.lean b/Ix/Resource/Basic.lean
new file mode 100644
index 000000000..c2632ddf4
--- /dev/null
+++ b/Ix/Resource/Basic.lean
@@ -0,0 +1,377 @@
+module
+
+public import Ix.Ixon
+
+/-!
+# Resource checking state
+
+Scope identifiers and owner identities are internal to one checking run. They
+are never lifetime parameters in an Ixon interface. All primitive transitions
+are total and fail closed; successful scope exit never restores ownership by
+assignment. Ending a loan only removes that particular loan.
+-/
+
+@[expose] public section
+
+namespace Ix.Resource
+
+open Ixon
+
+abbrev ScopeId := Nat
+abbrev OwnerId := Nat
+
+inductive Error where
+  | budget
+  | unbound (index : Nat)
+  | badReference (index : Nat)
+  | unresolvedSharing (index : Nat)
+  | unsupported (operation : String)
+  | typeMismatch
+  | binderMismatch
+  | usage (owner : OwnerId) (declared actual : Uses)
+  | moved (owner : OwnerId)
+  | sharedToUnique
+  | activeLoan (owner : OwnerId)
+  | escape (origin destination : ScopeId)
+  | unrestrictedEscape (origin : ScopeId)
+  | nonduplicable
+  | invalidBorrow
+  | invalidPlace
+  | invalidScope
+  deriving BEq, Repr, Inhabited
+
+structure Limits where
+  depth : Nat := 256
+  steps : Nat := 100000
+  deriving BEq, Repr, Inhabited
+
+/-- A value retains every origin in this list, including origins inherited
+through a closure, aggregate, projection, alias, or reborrow. -/
+structure Value where
+  type : Ixon.Expr
+  owned : Owned := .shared
+  origins : List ScopeId := []
+  /-- Shared values must be safe to duplicate. In particular a shared closure
+  cannot conceal a finite-use or uniquely consumed capture. -/
+  duplicable : Bool := true
+  /-- An unevaluated transfer from this binding; conversion consumes it once. -/
+  place : Option OwnerId := none
+  /-- Shared views keep the identity of their root owner through aliases. -/
+  loanRoot : Option OwnerId := none
+  deriving BEq, Repr, Inhabited
+
+structure Owner where
+  live : Bool := true
+  unique : Bool := false
+  loans : List ScopeId := []
+  deriving BEq, Repr, Inhabited
+
+structure Binding where
+  contract : BinderContract
+  value : Value
+  owner : Owner := { unique := value.owned == .unique }
+  demand : Uses := .erased
+  /-- Borrow creation captures an owner without consuming its quantity. -/
+  touched : Bool := false
+  deriving BEq, Repr, Inhabited
+
+structure State where
+  bindings : Array Binding := #[]
+  /-- Root 0 has no parent. Every new parent precedes its child. -/
+  parents : Array (Option ScopeId) := #[none]
+  remaining : Nat := 100000
+  deriving BEq, Repr, Inhabited
+
+abbrev CheckM := EStateM Error State
+
+def liftExcept : Except Error α → CheckM α
+  | .ok a => pure a
+  | .error e => throw e
+
+def tick : CheckM Unit := do
+  let s ← get
+  match s.remaining with
+  | 0 => throw .budget
+  | n + 1 => set { s with remaining := n }
+
+def binding (id : OwnerId) : CheckM Binding := do
+  match (← get).bindings[id]? with
+  | some b => return b
+  | none => throw (.unbound id)
+
+def setBinding (id : OwnerId) (b : Binding) : CheckM Unit := do
+  let s ← get
+  if id < s.bindings.size then
+    set { s with bindings := s.bindings.set! id b }
+  else throw (.unbound id)
+
+def pushBinding (contract : BinderContract) (value : Value) : CheckM OwnerId := do
+  let s ← get
+  let id := s.bindings.size
+  set { s with bindings := s.bindings.push { contract, value } }
+  return id
+
+def newScope (parent : ScopeId) : CheckM ScopeId := do
+  let s ← get
+  if parent < s.parents.size then
+    let id := s.parents.size
+    set { s with parents := s.parents.push (some parent) }
+    return id
+  else throw .invalidScope
+
+/-- Bounded traversal also rejects malformed/cyclic state supplied to this
+low-level function. Generated states always have decreasing parent indices. -/
+def outlivesAux (parents : Array (Option ScopeId)) (origin : ScopeId) :
+    Nat → ScopeId → Bool
+  | 0, _ => false
+  | fuel + 1, destination =>
+    if origin >= parents.size || destination >= parents.size then false
+    else if origin == destination then true
+    else match parents[destination]? with
+      | some (some parent) => outlivesAux parents origin fuel parent
+      | _ => false
+
+def outlives (parents : Array (Option ScopeId)) (origin destination : ScopeId) : Bool :=
+  outlivesAux parents origin (parents.size + 1) destination
+
+def checkOrigins (parents : Array (Option ScopeId)) :
+    List ScopeId → ScopeId → Except Error Unit
+  | [], _ => .ok ()
+  | origin :: rest, destination =>
+    if outlives parents origin destination then checkOrigins parents rest destination
+    else .error (.escape origin destination)
+
+def checkUnrestricted (origins : List ScopeId) : Except Error Unit :=
+  match origins with
+  | [] => .ok ()
+  | origin :: _ => .error (.unrestrictedEscape origin)
+
+def unionOrigins (a b : List ScopeId) : List ScopeId :=
+  b.foldl (fun acc origin => if acc.contains origin then acc else acc ++ [origin]) a
+
+def charge (id : OwnerId) (uses : Uses) : CheckM Unit := do
+  let b ← binding id
+  if !b.owner.live then throw (.moved id)
+  setBinding id { b with demand := b.demand.add uses, touched := true }
+
+def checkDemand (id : OwnerId) (declared actual : Uses) : Except Error Unit :=
+  if declared.covers actual then .ok () else .error (.usage id declared actual)
+
+def validateUsage (id : OwnerId) : CheckM Unit := do
+  let b ← binding id
+  liftExcept (checkDemand id b.contract.uses b.demand)
+
+/-- A move requires both exclusive availability and the absence of every
+active loan. There is no transition that restores a moved owner. -/
+def moveOwner (id : OwnerId) (owner : Owner) : Except Error Owner :=
+  if !owner.live then .error (.moved id)
+  else if !owner.unique then .error .sharedToUnique
+  else if !owner.loans.isEmpty then .error (.activeLoan id)
+  else .ok { owner with live := false }
+
+def shareOwner (id : OwnerId) (owner : Owner) : Except Error Owner :=
+  if !owner.live then .error (.moved id)
+  else .ok { owner with unique := false }
+
+def beginLoan (id : OwnerId) (scope : ScopeId) (owner : Owner) : Except Error Owner :=
+  if !owner.live then .error (.moved id)
+  else .ok { owner with loans := scope :: owner.loans }
+
+/-- Removing a loan preserves both liveness and the permanent sharing state. -/
+def endLoan (scope : ScopeId) (owner : Owner) : Owner :=
+  { owner with loans := owner.loans.filter (· != scope) }
+
+/-- Perform a place's ownership action once. Scope exit materializes its
+result before ending loans, even when the result is being inferred. -/
+def materialize (v : Value) : CheckM Value := do
+  if let some id := v.place then
+    let b ← binding id
+    let owner ← liftExcept <| match v.owned with
+      | .unique => moveOwner id b.owner
+      | .shared => shareOwner id b.owner
+    setBinding id { b with owner }
+  return { v with place := none }
+
+/-- Check a conversion and perform the transfer or permanent alias. Local
+conversion is relative to the inferred destination scope; it narrows an
+unrestricted value and preserves all earlier restrictions. -/
+def consumeAs (required : ValueContract) (destination : ScopeId) (v : Value) :
+    CheckM Value := do
+  let parents := (← get).parents
+  match required.locality with
+  | .unrestricted => liftExcept (checkUnrestricted v.origins)
+  | .local => liftExcept (checkOrigins parents v.origins destination)
+  if required.owned == .unique && v.owned != .unique then
+    throw .sharedToUnique
+  if required.owned == .shared && !v.duplicable then
+    throw .nonduplicable
+  let v ← materialize { v with owned := required.owned }
+  let origins := match required.locality with
+    | .unrestricted => v.origins
+    | .local => unionOrigins v.origins [destination]
+  return { v with origins }
+
+def invoke (v : Value) : CheckM Unit := do
+  if v.owned == .shared && !v.duplicable then throw .nonduplicable
+  if let some id := v.place then
+    let b ← binding id
+    if v.owned == .unique then
+      let owner ← liftExcept (moveOwner id b.owner)
+      setBinding id { b with owner }
+    else if !b.owner.live then throw (.moved id)
+
+def closeScope (scope : ScopeId) (result : Value) : CheckM Unit := do
+  let s ← get
+  let some (some parent) := s.parents[scope]? | throw .invalidScope
+  liftExcept (checkOrigins s.parents result.origins parent)
+  set { s with bindings := s.bindings.map fun (b : Binding) =>
+    { b with owner := endLoan scope b.owner } }
+
+def joinOwner (left right : Owner) : Owner :=
+  { live := left.live && right.live
+    unique := left.unique && right.unique
+    loans := unionOrigins left.loans right.loans }
+
+def joinValue (left right : Value) : Value :=
+  { type := left.type
+    owned := if left.owned == .unique && right.owned == .unique then .unique else .shared
+    origins := unionOrigins left.origins right.origins
+    duplicable := left.duplicable && right.duplicable
+    place := if left.place == right.place then left.place else none
+    loanRoot := if left.loanRoot == right.loanRoot then left.loanRoot else none }
+
+/-- The meaning of an internal scope bound, independent of the executable
+fuel-bounded ancestor walk. -/
+inductive Ancestor (parents : Array (Option ScopeId)) (origin : ScopeId) : ScopeId → Prop
+  | here (h : origin < parents.size) : Ancestor parents origin origin
+  | parent {scope parent : ScopeId} (h : parents[scope]? = some (some parent))
+      (outer : Ancestor parents origin parent) : Ancestor parents origin scope
+
+/-- Generated parent tables point strictly backwards. -/
+def ScopeTree (parents : Array (Option ScopeId)) : Prop :=
+  ∀ (scope parent : ScopeId), parents[scope]? = some (some parent) → parent < scope
+
+theorem root_scopeTree : ScopeTree #[none] := by
+  intro scope parent h
+  cases scope <;> simp at h
+
+theorem push_scopeTree (parents : Array (Option ScopeId)) (parent : ScopeId)
+    (tree : ScopeTree parents) (valid : parent < parents.size) :
+    ScopeTree (parents.push (some parent)) := by
+  intro scope outer h
+  rw [Array.getElem?_push] at h
+  split at h
+  · rename_i same
+    cases h
+    simpa [same] using valid
+  · exact tree scope outer h
+
+theorem ancestor_older (parents : Array (Option ScopeId)) (origin destination : ScopeId)
+    (tree : ScopeTree parents) (h : Ancestor parents origin destination) : origin ≤ destination := by
+  induction h with
+  | here => exact Nat.le_refl _
+  | parent lookup _ ih =>
+    have older := tree _ _ lookup
+    exact Nat.le_trans ih (Nat.le_of_lt older)
+
+theorem outlivesAux_sound (parents : Array (Option ScopeId)) (origin fuel destination : Nat)
+    (h : outlivesAux parents origin fuel destination = true) :
+    Ancestor parents origin destination := by
+  induction fuel generalizing destination with
+  | zero => simp [outlivesAux] at h
+  | succ fuel ih =>
+    simp only [outlivesAux] at h
+    split at h
+    · simp at h
+    · rename_i valid
+      split at h
+      · rename_i same
+        have eq : origin = destination := by simpa using same
+        subst destination
+        apply Ancestor.here
+        have inside : ¬ origin >= parents.size := by
+          intro outside
+          exact valid (by simp [outside])
+        exact Nat.lt_of_not_ge inside
+      · split at h
+        · rename_i parent hp
+          exact Ancestor.parent hp (ih parent h)
+        · simp at h
+
+theorem outlives_sound (parents : Array (Option ScopeId)) (origin destination : Nat)
+    (h : outlives parents origin destination = true) : Ancestor parents origin destination :=
+  outlivesAux_sound parents origin _ destination h
+
+theorem fresh_scope_cannot_escape (parents : Array (Option ScopeId)) (parent destination : ScopeId)
+    (tree : ScopeTree parents) (valid : parent < parents.size) (older : destination < parents.size) :
+    outlives (parents.push (some parent)) parents.size destination = false := by
+  cases result : outlives (parents.push (some parent)) parents.size destination with
+  | false => rfl
+  | true =>
+    have ancestor := outlives_sound _ _ _ result
+    have order := ancestor_older _ _ _ (push_scopeTree parents parent tree valid) ancestor
+    exact False.elim ((Nat.not_le_of_lt older) order)
+
+theorem checkOrigins_sound (parents : Array (Option ScopeId)) (origins : List ScopeId)
+    (destination : ScopeId) (h : checkOrigins parents origins destination = .ok ()) :
+    ∀ origin ∈ origins, Ancestor parents origin destination := by
+  induction origins with
+  | nil => simp
+  | cons origin rest ih =>
+    simp only [checkOrigins] at h
+    split at h
+    · rename_i allowed
+      intro x hx
+      simp only [List.mem_cons] at hx
+      rcases hx with rfl | hx
+      · exact outlives_sound parents x destination allowed
+      · exact ih h x hx
+    · simp at h
+
+@[simp] theorem endLoan_live (scope : ScopeId) (owner : Owner) :
+    (endLoan scope owner).live = owner.live := rfl
+
+@[simp] theorem endLoan_unique (scope : ScopeId) (owner : Owner) :
+    (endLoan scope owner).unique = owner.unique := rfl
+
+theorem moveOwner_requires (id : OwnerId) (before after : Owner)
+    (h : moveOwner id before = .ok after) :
+    before.live = true ∧ before.unique = true ∧ before.loans = [] ∧ after.live = false := by
+  rcases before with ⟨live, unique, loans⟩
+  cases live <;> cases unique <;> cases loans <;>
+    simp_all [moveOwner]
+  cases h
+  rfl
+
+theorem shareOwner_permanent (id : OwnerId) (before after : Owner)
+    (h : shareOwner id before = .ok after) : after.unique = false := by
+  rcases before with ⟨live, unique, loans⟩
+  cases live <;> simp_all [shareOwner]
+  cases h
+  rfl
+
+theorem checkUnrestricted_sound (origins : List ScopeId)
+    (h : checkUnrestricted origins = .ok ()) : origins = [] := by
+  cases origins <;> simp_all [checkUnrestricted]
+
+theorem joinOwner_live (left right : Owner)
+    (h : (joinOwner left right).live = true) : left.live = true ∧ right.live = true := by
+  simpa [joinOwner] using h
+
+theorem joinOwner_unique (left right : Owner)
+    (h : (joinOwner left right).unique = true) :
+    left.unique = true ∧ right.unique = true := by
+  simpa [joinOwner] using h
+
+theorem checkDemand_sound (id : OwnerId) (declared actual : Uses) (count : Nat)
+    (accepted : checkDemand id declared actual = .ok ()) (demand : actual.admits count) :
+    declared.admits count := by
+  simp only [checkDemand] at accepted
+  split at accepted
+  · rename_i covers
+    exact Uses.covers_sound declared actual count covers demand
+  · simp at accepted
+
+end Ix.Resource
+
+end
diff --git a/Ix/Resource/Check.lean b/Ix/Resource/Check.lean
new file mode 100644
index 000000000..ee9c82ffe
--- /dev/null
+++ b/Ix/Resource/Check.lean
@@ -0,0 +1,536 @@
+module
+
+public import Ix.Resource.Basic
+
+/-!
+# Deterministic checking of the resource fragment
+
+The address adapter supplies a closed, globally indexed program. Interfaces
+of recursive definitions are checked simultaneously. Definitions never acquire
+an optimistic no-capture summary: calls use the declared interface and retain
+all permitted argument/closure origins. An external interface or special
+primitive is an explicit profile assumption, not auxiliary source metadata.
+
+Erased typing is a separate prerequisite. This module also compares the full
+resource structure of types, so erased definitional equality cannot launder a
+different higher-order contract. Unsupported reductions exhaust a fixed bound
+or report an error instead of silently discarding modes.
+-/
+
+@[expose] public section
+
+namespace Ix.Resource
+
+open Ixon
+
+inductive DeclKind where
+  | definition
+  | assumption
+  | constructor
+  | typeConstructor
+  deriving BEq, Repr, Inhabited
+
+structure Declaration where
+  type : Ixon.Expr
+  body : Option Ixon.Expr := none
+  kind : DeclKind := .definition
+  deriving BEq, Repr, Inhabited
+
+/-- Checked transparent fields. The adapter derives these from the addressed
+constructor interface; an unknown projection has no default resource rule. -/
+structure Field where
+  typeRef : UInt64
+  index : UInt64
+  type : Ixon.Expr
+  contract : ValueContract
+  deriving BEq, Repr, Inhabited
+
+structure Program where
+  declarations : Array Declaration
+  /-- Members and constructors addressed by the same mutual block. -/
+  groups : Array (Array Nat) := #[]
+  /-- Additional addressed executable syntax, currently recursor rules.
+  These participate in dependency/relevance scanning even when the interface
+  requires a profile assumption instead of ordinary lambda checking. -/
+  auxiliary : Array (Nat × Ixon.Expr) := #[]
+  sharing : Array Ixon.Expr := #[]
+  fields : Array Field := #[]
+  natType : Option Ixon.Expr := none
+  stringType : Option Ixon.Expr := none
+  /-- Types whose shared views have a checked, duplicable representation.
+  Abstract type parameters are deliberately absent from this list. -/
+  shareableTypes : Array UInt64 := #[]
+  /-- Profile-bound non-strict selection primitives, with exactly selector,
+  left alternative, and right alternative as their three arguments. -/
+  choices : Array UInt64 := #[]
+  deriving BEq, Repr, Inhabited
+
+structure Context where
+  program : Program
+  /-- Oldest binding first; Ixon variables still count from the innermost. -/
+  vars : Array OwnerId := #[]
+  scope : ScopeId := 0
+  deriving Inhabited
+
+def declaration (program : Program) (index : UInt64) : CheckM Declaration :=
+  match program.declarations[index.toNat]? with
+  | some d => pure d
+  | none => throw (.badReference index.toNat)
+
+def expansion (program : Program) (index : UInt64) : CheckM Ixon.Expr :=
+  match program.sharing[index.toNat]? with
+  | some e => pure e
+  | none => throw (.unresolvedSharing index.toNat)
+
+def literalType (type : Option Ixon.Expr) : CheckM Ixon.Expr :=
+  match type with
+  | some type => pure type
+  | none => throw (.unsupported "literal type is absent from the addressed profile")
+
+def checkedIndex (n : Nat) : CheckM UInt64 :=
+  if n < UInt64.size then pure n.toUInt64 else throw (.unsupported "readVariable index overflow")
+
+def shift (program : Program) : Nat → Ixon.Expr → Nat → Nat → CheckM Ixon.Expr
+  | 0, _, _, _ => throw .budget
+  | fuel + 1, e, amount, cutoff => do
+    tick
+    match e with
+    | .var idx =>
+      if idx.toNat < cutoff then return e
+      else return .var (← checkedIndex (idx.toNat + amount))
+    | .app fn arg =>
+      return .app (← shift program fuel fn amount cutoff) (← shift program fuel arg amount cutoff)
+    | .lam c ty body =>
+      return .lam c (← shift program fuel ty amount cutoff)
+        (← shift program fuel body amount (cutoff + 1))
+    | .all c r ty body =>
+      return .all c r (← shift program fuel ty amount cutoff)
+        (← shift program fuel body amount (cutoff + 1))
+    | .letE c ty val body =>
+      return .letE c (← shift program fuel ty amount cutoff)
+        (← shift program fuel val amount cutoff)
+        (← shift program fuel body amount (cutoff + 1))
+    | .prj t i val => return .prj t i (← shift program fuel val amount cutoff)
+    | .share idx => shift program fuel (← expansion program idx) amount cutoff
+    | .recur .. => throw (.unsupported "unresolved recursive reference")
+    | _ => return e
+
+def substitute (program : Program) : Nat → Ixon.Expr → Ixon.Expr → Nat → CheckM Ixon.Expr
+  | 0, _, _, _ => throw .budget
+  | fuel + 1, e, value, depth => do
+    tick
+    match e with
+    | .var idx =>
+      if idx.toNat == depth then shift program fuel value depth 0
+      else if idx.toNat > depth then return .var (idx - 1)
+      else return e
+    | .app fn arg =>
+      return .app (← substitute program fuel fn value depth)
+        (← substitute program fuel arg value depth)
+    | .lam c ty body =>
+      return .lam c (← substitute program fuel ty value depth)
+        (← substitute program fuel body value (depth + 1))
+    | .all c r ty body =>
+      return .all c r (← substitute program fuel ty value depth)
+        (← substitute program fuel body value (depth + 1))
+    | .letE c ty val body =>
+      return .letE c (← substitute program fuel ty value depth)
+        (← substitute program fuel val value depth)
+        (← substitute program fuel body value (depth + 1))
+    | .prj t i val => return .prj t i (← substitute program fuel val value depth)
+    | .share idx => substitute program fuel (← expansion program idx) value depth
+    | .recur .. => throw (.unsupported "unresolved recursive reference")
+    | _ => return e
+
+/-- This reduction is only for resource interfaces. The ordinary typechecker
+separately validates universes, dependent types, and definitional equality. -/
+def whnf (program : Program) : Nat → Ixon.Expr → CheckM Ixon.Expr
+  | 0, _ => throw .budget
+  | fuel + 1, e => do
+    tick
+    match e with
+    | .share idx => whnf program fuel (← expansion program idx)
+    | .letE _ _ value body =>
+      whnf program fuel (← substitute program fuel body value 0)
+    | .app fn arg =>
+      let fn ← whnf program fuel fn
+      match fn with
+      | .lam _ _ body => whnf program fuel (← substitute program fuel body arg 0)
+      | _ => return .app fn arg
+    | .ref idx _ =>
+      let d ← declaration program idx
+      match d.body with
+      | some body => whnf program fuel body
+      | none => return e
+    | .recur .. => throw (.unsupported "unresolved recursive reference")
+    | _ => return e
+
+def compatible (program : Program) : Nat → Ixon.Expr → Ixon.Expr → CheckM Bool
+  | 0, _, _ => throw .budget
+  | fuel + 1, left, right => do
+    tick
+    -- Exact syntax is safe even when an opaque type has no reduction rule.
+    if left == right then return true
+    let left ← whnf program fuel left
+    let right ← whnf program fuel right
+    match left, right with
+    | .all c r a b, .all c' r' a' b' =>
+      if c != c' || r != r' then return false
+      if !(← compatible program fuel a a') then return false
+      compatible program fuel b b'
+    | .lam c a b, .lam c' a' b' =>
+      if c != c' then return false
+      if !(← compatible program fuel a a') then return false
+      compatible program fuel b b'
+    | .app f a, .app f' a' =>
+      if !(← compatible program fuel f f') then return false
+      compatible program fuel a a'
+    | .prj t i v, .prj t' i' v' =>
+      if t != t' || i != i' then return false
+      compatible program fuel v v'
+    | .sort _, .sort _ => return true
+    | .ref i _, .ref j _ => return i == j
+    | _, _ => return left == right
+
+def requireType (program : Program) (fuel : Nat) (actual expected : Ixon.Expr) : CheckM Unit := do
+  if !(← compatible program fuel actual expected) then throw .typeMismatch
+
+def arrow (program : Program) (fuel : Nat) (type : Ixon.Expr) :
+    CheckM (BinderContract × ValueContract × Ixon.Expr × Ixon.Expr) := do
+  match ← whnf program fuel type with
+  | .all input result domain codomain => return (input, result, domain, codomain)
+  | _ => throw (.unsupported "a callable interface must expose its arrow contracts")
+
+def isShareable (program : Program) (fuel : Nat) (type : Ixon.Expr) : CheckM Bool := do
+  let type ← whnf program fuel type
+  match type with
+  | .ref idx _ => return program.shareableTypes.contains idx
+  | .sort _ => return true
+  | _ => return false
+
+def readVariable (ctx : Context) (fuel : Nat) (index : UInt64) (uses : Uses) : CheckM Value := do
+  let n := index.toNat
+  if n >= ctx.vars.size then throw (.unbound n)
+  let id := ctx.vars[ctx.vars.size - 1 - n]!
+  let b ← binding id
+  charge id uses
+  if let some root := b.value.loanRoot then
+    let owner ← binding root
+    if !owner.owner.live then throw (.moved root)
+  let type ← shift ctx.program fuel b.value.type (n + 1) 0
+  return { b.value with
+    type
+    place := some id
+    owned := if b.owner.unique then .unique else .shared }
+
+/-- Resolve a borrow place without charging a consumption. Every projection
+must have a checked field rule; all projected loans suspend the whole root. -/
+def place (ctx : Context) : Nat → Ixon.Expr → CheckM Value
+  | 0, _ => throw .budget
+  | fuel + 1, e => do
+    tick
+    match e with
+    | .var idx =>
+      let value ← readVariable ctx fuel idx .erased
+      let some id := value.place | throw .invalidPlace
+      if (← binding id).contract.uses == .erased then
+        throw (.unsupported "an erased binding cannot be borrowed")
+      return value
+    | .share idx => place ctx fuel (← expansion ctx.program idx)
+    | .prj t i value =>
+      let value ← place ctx fuel value
+      let some field := ctx.program.fields.find? (fun f => f.typeRef == t && f.index == i)
+        | throw (.unsupported "projection has no checked field rule")
+      let duplicable ← if field.contract.owned == .shared then pure true
+        else isShareable ctx.program fuel field.type
+      return { value with
+        type := field.type
+        duplicable
+        owned := if value.owned == .unique && field.contract.owned == .unique then .unique else .shared }
+    | _ => throw .invalidPlace
+
+/-- Infer the interface before executing any resource transition. Calls need
+the actual result locality to choose their scope: a call returning an
+unrestricted value may inspect a short-lived view even when its result will
+subsequently be narrowed to an outer local scope. -/
+def typeOf : Nat → Context → Ixon.Expr → CheckM Ixon.Expr
+  | 0, _, _ => throw .budget
+  | fuel + 1, ctx, e => do
+    tick
+    match e with
+    | .var index =>
+      let n := index.toNat
+      if n >= ctx.vars.size then throw (.unbound n)
+      let b ← binding ctx.vars[ctx.vars.size - 1 - n]!
+      shift ctx.program fuel b.value.type (n + 1) 0
+    | .ref index _ => return (← declaration ctx.program index).type
+    | .share index => typeOf fuel ctx (← expansion ctx.program index)
+    | .recur .. => throw (.unsupported "unresolved recursive reference")
+    | .sort _ | .all .. => return .sort 0
+    | .nat _ => literalType ctx.program.natType
+    | .str _ => literalType ctx.program.stringType
+    | .prj typeRef index _ =>
+      let some field := ctx.program.fields.find? (fun f => f.typeRef == typeRef && f.index == index)
+        | throw (.unsupported "projection has no checked field rule")
+      return field.type
+    | .app fn arg =>
+      let (_, _, _, codomain) ← arrow ctx.program fuel (← typeOf fuel ctx fn)
+      substitute ctx.program fuel codomain arg 0
+    | .lam input domain body =>
+      let before ← get
+      let id ← pushBinding input { type := domain }
+      let codomain ← typeOf fuel { ctx with vars := ctx.vars.push id } body
+      modify fun s => { s with bindings := before.bindings }
+      return .all input .shared domain codomain
+    | .letE contract type initializer body =>
+      let before ← get
+      let id ← pushBinding contract.binder { type }
+      let type ← typeOf fuel { ctx with vars := ctx.vars.push id } body
+      modify fun s => { s with bindings := before.bindings }
+      substitute ctx.program fuel type initializer 0
+
+def splitApp (program : Program) :
+    Nat → Ixon.Expr → List Ixon.Expr → CheckM (Ixon.Expr × List Ixon.Expr)
+  | 0, _, _ => throw .budget
+  | fuel + 1, e, args => do
+    tick
+    match e with
+    | .app fn arg => splitApp program fuel fn (arg :: args)
+    | .share index => splitApp program fuel (← expansion program index) args
+    | _ => return (e, args)
+
+def finishValue (ctx : Context) (fuel : Nat) (destination : ScopeId)
+    (expected : Option (Ixon.Expr × ValueContract)) (value : Value) : CheckM Value := do
+  match expected with
+  | none => return value
+  | some (type, contract) =>
+    requireType ctx.program fuel value.type type
+    consumeAs contract destination value
+
+/-- Join only bindings that existed before an alternative. Branch-local
+bindings cannot escape: returned places have already been consumed, and
+retained local origins are checked before their lexical scopes close. -/
+def joinBindings (count : Nat) (left right : State) : CheckM (Array Binding) := do
+  let mut result := #[]
+  for i in [0:count] do
+    let some a := left.bindings[i]? | throw (.unbound i)
+    let some b := right.bindings[i]? | throw (.unbound i)
+    result := result.push { a with
+      owner := joinOwner a.owner b.owner
+      demand := a.demand.join b.demand
+      touched := a.touched || b.touched }
+  return result
+
+def analyze : Nat → Context → Ixon.Expr → Option (Ixon.Expr × ValueContract) →
+    ScopeId → Uses → CheckM Value
+  | 0, _, _, _, _, _ => throw .budget
+  | fuel + 1, ctx, e, expected, destination, grade => do
+    tick
+    -- Zero computation is checked by the prerequisite erased typechecker.
+    -- It has no ownership events, captures, or runtime origins.
+    if grade == .erased then
+      let type ← typeOf fuel ctx e
+      if let some (expectedType, _) := expected then
+        requireType ctx.program fuel type expectedType
+      return { type, owned := .unique }
+    if let some (type, _) := expected then
+      if let .sort _ ← whnf ctx.program fuel type then
+        return { type, owned := .unique }
+    if grade != .linear then
+      let before ← get
+      set { before with bindings := before.bindings.map fun (b : Binding) =>
+        { b with demand := .erased, touched := false } }
+      let output ← analyze fuel ctx e expected destination .linear
+      let after ← get
+      let mut bindings := after.bindings
+      for id in [0:before.bindings.size] do
+        let old := before.bindings[id]!
+        let used := after.bindings[id]!
+        bindings := bindings.set! id { used with
+          demand := old.demand.add (grade.mul used.demand)
+          touched := old.touched || used.touched }
+      set { after with bindings }
+      return output
+    let value ← match e with
+      | .share idx => analyze fuel ctx (← expansion ctx.program idx) expected destination grade
+      | .var idx => readVariable ctx fuel idx grade
+      | .ref idx _ =>
+        if ctx.program.choices.contains idx then
+          throw (.unsupported "selection primitives cannot escape as function values")
+        let d ← declaration ctx.program idx
+        pure { type := d.type }
+      | .recur .. => throw (.unsupported "unresolved recursive reference")
+      | .sort _ | .all .. => pure { type := .sort 0, owned := .unique }
+      | .nat _ => pure { type := ← literalType ctx.program.natType, owned := .unique }
+      | .str _ => pure { type := ← literalType ctx.program.stringType, owned := .unique }
+      | .lam input domain body => do
+        let (result, codomain) ← match expected with
+          | some (type, _) => do
+            let (declared, result, ty, codomain) ← arrow ctx.program fuel type
+            if input != declared then throw .binderMismatch
+            requireType ctx.program fuel domain ty
+            pure (result, some codomain)
+          | none => pure (.shared, none)
+        let before ← get
+        -- Deferred closure checking gets fresh per-invocation demands.
+        set { before with bindings := before.bindings.map fun (b : Binding) =>
+          { b with demand := .erased, touched := false } }
+        let callerScope ← newScope ctx.scope
+        let bodyScope ← newScope callerScope
+        let origins := if input.value.locality == .local then [callerScope] else []
+        let duplicable ← if input.value.owned == .shared then pure true
+          else isShareable ctx.program fuel domain
+        let parameter ← pushBinding input {
+          type := domain
+          owned := input.value.owned
+          origins
+          duplicable }
+        let bodyCtx := { ctx with vars := ctx.vars.push parameter, scope := bodyScope }
+        let bodyExpected := codomain.map (fun ty => (ty, result))
+        let output ← analyze fuel bodyCtx body bodyExpected callerScope .linear
+        let output ← if bodyExpected.isSome then pure output else consumeAs result callerScope output
+        validateUsage parameter
+        let after ← get
+        let mut origins := []
+        let mut duplicable := true
+        let mut bindings := before.bindings
+        for id in [0:before.bindings.size] do
+          let old := before.bindings[id]!
+          let used := after.bindings[id]!
+          let mut owner := used.owner
+          let mut demand := used.demand
+          if used.touched then
+            origins := unionOrigins origins old.value.origins
+            if old.contract.uses != .many || !old.value.duplicable then duplicable := false
+            if old.owner.unique then
+              -- Capturing an owner transfers its availability even when the
+              -- body only borrows it. An explicit outer view permits reusable
+              -- local closures without transferring that owner.
+              let _ ← liftExcept (moveOwner id old.owner)
+              owner := { owner with live := false }
+              if demand == .erased then demand := .linear
+              duplicable := false
+          bindings := bindings.set! id { old with
+            owner
+            demand := old.demand.add (grade.mul demand)
+            touched := old.touched || used.touched }
+        set { after with bindings }
+        let codomain := codomain.getD output.type
+        pure {
+          type := .all input result domain codomain
+          owned := .unique
+          origins
+          duplicable }
+      | .letE contract type initializer body => do
+        let scope ← newScope ctx.scope
+        let inner := { ctx with scope }
+        let initialized ← match contract.kind with
+          | .value =>
+            analyze fuel ctx initializer (some (type, contract.binder.value))
+              (if contract.binder.value.locality == .local then scope else destination)
+              (grade.mul contract.binder.uses)
+          | .borrowShared => do
+            if contract.binder.value != .localShared then throw .invalidBorrow
+            let v ← place ctx fuel initializer
+            requireType ctx.program fuel v.type type
+            if !(← isShareable ctx.program fuel type) && !v.duplicable then throw .nonduplicable
+            let some ownerPlace := v.place | throw .invalidPlace
+            let root := v.loanRoot.getD ownerPlace
+            let b ← binding root
+            let owner ← liftExcept (beginLoan root scope b.owner)
+            setBinding root { b with owner }
+            pure { v with
+              owned := .shared
+              duplicable := true
+              origins := unionOrigins v.origins [scope]
+              place := none
+              loanRoot := some root }
+        let id ← pushBinding contract.binder { initialized with type }
+        let bodyCtx := { inner with vars := inner.vars.push id }
+        let bodyExpected ← match expected with
+          | none => pure none
+          | some (ty, mode) => pure (some (← shift ctx.program fuel ty 1 0, mode))
+        let output ← analyze fuel bodyCtx body bodyExpected destination grade
+        validateUsage id
+        let output ← materialize output
+        closeScope scope output
+        let type ← substitute ctx.program fuel output.type initializer 0
+        pure { output with type }
+      | .prj typeRef index value => do
+        let value ← analyze fuel ctx value none destination grade
+        let some field := ctx.program.fields.find? (fun f => f.typeRef == typeRef && f.index == index)
+          | throw (.unsupported "projection has no checked field rule")
+        let duplicable ← if field.contract.owned == .shared then pure true
+          else isShareable ctx.program fuel field.type
+        pure { value with
+          type := field.type
+          duplicable
+          owned := if value.owned == .unique && field.contract.owned == .unique then .unique else .shared }
+      | .app fn arg => do
+        let ordinary : CheckM Value := do
+          let fnType ← typeOf fuel ctx fn
+          let (input, result, domain, codomain) ← arrow ctx.program fuel fnType
+          let callScope := if result.locality == .local then destination else ctx.scope
+          let fnValue ← analyze fuel ctx fn none callScope grade
+          requireType ctx.program fuel fnValue.type fnType
+          invoke fnValue
+          let argValue ← analyze fuel ctx arg (some (domain, input.value)) callScope (grade.mul input.uses)
+          let type ← substitute ctx.program fuel codomain arg 0
+          let origins := if result.locality == .local then
+            unionOrigins (unionOrigins fnValue.origins argValue.origins) [callScope] else []
+          let duplicable ← if result.owned == .shared then pure true
+            else isShareable ctx.program fuel type
+          pure {
+            type
+            owned := result.owned
+            origins
+            duplicable }
+        let (head, arguments) ← splitApp ctx.program fuel e []
+        match head, arguments with
+        | .ref index _, [selector, left, right] =>
+          if ctx.program.choices.contains index then
+            let decl ← declaration ctx.program index
+            let (c, _, selectorType, tail) ← arrow ctx.program fuel decl.type
+            let _ ← analyze fuel ctx selector (some (selectorType, c.value)) ctx.scope (grade.mul c.uses)
+            let tail ← substitute ctx.program fuel tail selector 0
+            let (_, _, leftType, tail) ← arrow ctx.program fuel tail
+            let tail ← substitute ctx.program fuel tail left 0
+            let (_, result, rightType, outputType) ← arrow ctx.program fuel tail
+            let outputType ← substitute ctx.program fuel outputType right 0
+            requireType ctx.program fuel leftType rightType
+            requireType ctx.program fuel leftType outputType
+            let before ← get
+            let left ← analyze fuel ctx left (some (leftType, result)) destination grade
+            let leftState ← get
+            -- Preserve fresh scope identities and charge the shared budget
+            -- while restoring the pre-branch owner/use state.
+            set { leftState with bindings := before.bindings }
+            let right ← analyze fuel ctx right (some (rightType, result)) destination grade
+            let rightState ← get
+            let bindings ← joinBindings before.bindings.size leftState rightState
+            set { rightState with bindings }
+            pure { joinValue left right with type := outputType }
+          else ordinary
+        | _, _ =>
+          if let .ref index _ := head then
+            if ctx.program.choices.contains index then
+              throw (.unsupported "selection primitives require a complete application")
+          ordinary
+    finishValue ctx fuel destination expected value
+
+def checkDefinition (program : Program) (index : Nat) (limits : Limits := {}) : Except Error Unit := do
+  let some declaration := program.declarations[index]? | throw (.badReference index)
+  let some body := declaration.body | throw (.unsupported "definition has no body")
+  let action : CheckM Unit := do
+    let scope ← newScope 0
+    let _ ← analyze limits.depth { program, scope } body
+      (some (declaration.type, .shared)) scope .linear
+    pure ()
+  match action.run { remaining := limits.steps } with
+  | .ok _ _ => pure ()
+  | .error error _ => throw error
+
+end Ix.Resource
+
+end
+
diff --git a/Ix/Resource/Claim.lean b/Ix/Resource/Claim.lean
new file mode 100644
index 000000000..0b7fd2efb
--- /dev/null
+++ b/Ix/Resource/Claim.lean
@@ -0,0 +1,31 @@
+module
+
+public import Ix.Claim
+public import Ix.Resource.Validate
+
+/-! A resource claim binds the complete constant set, format v3,
+resource-v1 validator, and the canonical policy bytes. -/
+
+@[expose] public section
+
+namespace Ix.Resource
+
+def checkClaim (env : Ixon.Env) (profile : Profile) (claim : Ix.Claim) :
+    Except String AddressedProgram := do
+  let .resource root expectedProfile := claim
+    | throw "resource validator: claim uses a different validator"
+  unless env.merkleRoot == some root do
+    throw "resource validator: claim subject differs from the complete constant set"
+  unless (← profile.address) == expectedProfile do
+    throw "resource validator: claim profile differs from the supplied policy"
+  validate env profile
+
+def makeClaim (env : Ixon.Env) (profile : Profile) : Except String Ix.Claim := do
+  let some root := env.merkleRoot | throw "resource validator: empty claim subject"
+  let claim := Ix.Claim.resource root (← profile.address)
+  let _ ← checkClaim env profile claim
+  return claim
+
+end Ix.Resource
+
+end
diff --git a/Ix/Resource/Validate.lean b/Ix/Resource/Validate.lean
new file mode 100644
index 000000000..c668d7286
--- /dev/null
+++ b/Ix/Resource/Validate.lean
@@ -0,0 +1,52 @@
+module
+
+public import Ix.Resource.Addressed
+public import Ix.Tc.Driver
+
+/-! The combined native validation boundary. Both validators consume the same
+addressed v3 bytes. Kernel typechecking alone has no resource meaning. -/
+
+@[expose] public section
+
+namespace Ix.Resource
+
+/-- A minimal built-in profile, restricted to actual interfaces present in
+the supplied closure. All assumptions are explicit in its committed bytes. -/
+def standardProfile (env : Ixon.Env) : Profile :=
+  let primitives := Ix.Tc.PrimAddrs.canonical
+  let present := fun address => if env.consts.contains address then some address else none
+  { natType := present primitives.nat
+    stringType := present primitives.string
+    shareableTypes := (#[primitives.nat, primitives.boolType, primitives.string].filter
+      env.consts.contains).qsort (fun a b => Address.cmpBytes a b == .lt) }
+
+/-- Literal interpretation is fixed by the typechecker, not chosen by the
+profile. A profile may omit unused literal types, but cannot redirect them. -/
+def checkLiteralProfile (profile : Profile) : Except String Unit := do
+  let primitives := Ix.Tc.PrimAddrs.canonical
+  for (selected, actual) in #[(profile.natType, primitives.nat), (profile.stringType, primitives.string)] do
+    if let some selected := selected then
+      unless selected == actual do throw "resource validator: literal type differs from the kernel primitive identity"
+
+/-- Rebuild the anonymous input from bounded raw byte windows. Lean's public
+LazyConstant record permits constructing a conflicting materialized cache;
+neither validator may trust that cache as a replacement for committed bytes. -/
+def rawTypingEnv (env : Ixon.Env) : Ixon.Env := {
+  consts := env.consts.fold (init := {}) fun result address lazy =>
+    let bytes := lazy.rawBytes
+    result.insert address (Ixon.LazyConstant.ofSlice bytes 0 bytes.size)
+  blobs := env.blobs
+  anonHints := env.anonHints }
+
+def validate (env : Ixon.Env) (profile : Profile) : Except String AddressedProgram := do
+  checkLiteralProfile profile
+  let resolved ← Addressed.checkResources env profile
+  let checked ← Ix.Tc.checkEnvAnon (rawTypingEnv env) { verifyHashes := true }
+  for result in checked do
+    if let some error := result.err? then
+      throw s!"resource validator: erased typing failed at {result.addr}: {error}"
+  return resolved
+
+end Ix.Resource
+
+end
diff --git a/Ix/SemanticContract.lean b/Ix/SemanticContract.lean
new file mode 100644
index 000000000..4ee692adb
--- /dev/null
+++ b/Ix/SemanticContract.lean
@@ -0,0 +1,183 @@
+module
+
+public import Ix.Ixon
+
+/-!
+# Contracts inside the source expression pipeline
+
+Resolved source occurrences are decorated before canonicalization. This
+reserved metadata frame is an intermediate semantic node: its fields affect
+equality, ordering, and compilation, and are consumed into the Ixon binder.
+It is never an optional presentation hint or a resource-validity certificate.
+-/
+
+@[expose] public section
+
+namespace Ix.SemanticContract
+
+def key : Lean.Name := `ix.contract
+
+def toLeanName : Ix.Name → Lean.Name
+  | .anonymous _ => .anonymous
+  | .str parent text _ => .str (toLeanName parent) text
+  | .num parent index _ => .num (toLeanName parent) index
+
+def reserved (name : Ix.Name) : Bool := key.isPrefixOf (toLeanName name)
+
+def hasMetadata (data : Array (Ix.Name × Ix.DataValue)) : Bool :=
+  data.any fun (name, _) => reserved name
+
+def leanFields (data : Lean.MData) : List (Lean.Name × Lean.DataValue) :=
+  data.entries.filter fun (name, _) => key.isPrefixOf name
+
+inductive Kind where
+  | lam | all | letE
+  deriving BEq, Repr, Inhabited
+
+structure Contract where
+  kind : Kind
+  binder : Ixon.BinderContract
+  result : Ixon.ValueContract := .shared
+  letKind : Ixon.LetKind := .value
+  deriving BEq, Repr, Inhabited
+
+def Contract.kindCode (contract : Contract) : Nat :=
+  match contract.kind with | .lam => 0 | .all => 1 | .letE => 2
+
+def Contract.code (contract : Contract) : Nat :=
+  match contract.kind with
+  | .lam => contract.binder.toBits.toNat
+  | .all => (Ixon.packAllContract contract.binder contract.result).toNat
+  | .letE => contract.binder.toBits.toNat + (if contract.letKind == .borrowShared then 16 else 0)
+
+def Contract.orderKey (contract : Contract) : Nat := contract.kindCode * 64 + contract.code
+
+def Contract.metadata (contract : Contract) : Lean.MData :=
+  ({} : Lean.MData) |>.setNat key 3
+    |>.setNat `ix.contract.kind contract.kindCode
+    |>.setNat `ix.contract.code contract.code
+
+def Contract.attach (contract : Contract) (expr : Lean.Expr) : Lean.Expr :=
+  .mdata contract.metadata expr
+
+def Contract.isOrdinary (contract : Contract) : Bool :=
+  contract.binder == .many && contract.result == .shared && contract.letKind == .value
+
+def decode (kind code : Nat) : Except String Contract := do
+  let k ← match kind with
+    | 0 => pure Kind.lam | 1 => pure Kind.all | 2 => pure Kind.letE
+    | _ => throw "invalid semantic contract kind"
+  let limit := match k with | .lam => 16 | .all => 64 | .letE => 32
+  if code >= limit then throw "reserved semantic contract bits"
+  let some binder := Ixon.BinderContract.ofBits? (code % 16).toUInt8
+    | throw "invalid semantic binder contract"
+  let result ← if k == .all then do
+    let some result := Ixon.ValueContract.ofBits? (code / 16).toUInt8
+      | throw "invalid semantic result contract"
+    pure result
+  else pure .shared
+  let letKind := if k == .letE && code >= 16 then Ixon.LetKind.borrowShared else .value
+  if letKind == .borrowShared && binder.value != .localShared then
+    throw "shared borrow requires a shared local view"
+  return { kind := k, binder, result, letKind }
+
+/-- A semantic frame has exactly these three fields. Other metadata may wrap
+it in separate frames, keeping native Lean hints independent. -/
+def read (data : Array (Ix.Name × Ix.DataValue)) : Except String Contract := do
+  if data.size != 3 then throw "malformed semantic contract frame"
+  let mut version : Option Nat := none
+  let mut kind : Option Nat := none
+  let mut code : Option Nat := none
+  for (name, value) in data do
+    let .ofNat value := value | throw "semantic contract fields must be natural numbers"
+    let name := toLeanName name
+    if name == key && version.isNone then version := some value
+    else if name == `ix.contract.kind && kind.isNone then kind := some value
+    else if name == `ix.contract.code && code.isNone then code := some value
+    else throw "unknown or duplicate semantic contract field"
+  unless version == some 3 do throw "unsupported semantic contract version"
+  let some kindValue := kind | throw "missing semantic contract kind"
+  let some codeValue := code | throw "missing semantic contract code"
+  decode kindValue codeValue
+
+def Contract.lower (contract : Contract) (source : Ix.Expr) (compiled : Ixon.Expr) :
+    Except String Ixon.Expr := do
+  match contract.kind, source, compiled with
+  | .lam, .lam .., .lam _ type body => return .lam contract.binder type body
+  | .all, .forallE .., .all _ _ type body => return .all contract.binder contract.result type body
+  | .letE, .letE .., .letE c type value body =>
+    return .letE { c with binder := contract.binder, kind := contract.letKind } type value body
+  | _, _, _ => throw "semantic contract is not attached to its original binder"
+
+/-- Inspect an entire source expression before rewrites can remove subterms. -/
+def inspect (top : Ix.Expr) : Except String Bool := do
+  let mut seen : Std.HashSet Ix.Expr := {}
+  let mut stack := #[top]
+  let mut annotated := false
+  while !stack.isEmpty do
+    let e := stack.back!
+    stack := stack.pop
+    if seen.contains e then continue
+    seen := seen.insert e
+    match e with
+    | .app fn arg _ => stack := stack.push fn |>.push arg
+    | .lam _ type body _ _ | .forallE _ type body _ _ =>
+      stack := stack.push type |>.push body
+    | .letE _ type value body _ _ => stack := stack.push type |>.push value |>.push body
+    | .proj _ _ value _ => stack := stack.push value
+    | .mdata data inner _ =>
+      if hasMetadata data then
+        let contract ← read data
+        let valid := match contract.kind, inner with
+          | .lam, .lam .. | .all, .forallE .. | .letE, .letE .. => true
+          | _, _ => false
+        unless valid do throw "semantic contract is not attached to its original binder"
+        annotated := true
+      stack := stack.push inner
+    | _ => pure ()
+  return annotated
+
+/-- Reconstruct only committed binder fields; optional metadata cannot
+supply or replace semantic contracts. -/
+def ofIxon? : Ixon.Expr → Option Contract
+  | .lam binder _ _ =>
+    if binder == .many then none else some { kind := .lam, binder }
+  | .all binder result _ _ =>
+    if binder == .many && result == .shared then none
+    else some { kind := .all, binder, result }
+  | .letE c _ _ _ =>
+    if c.binder == .many && c.kind == .value then none
+    else some { kind := .letE, binder := c.binder, letKind := c.kind }
+  | _ => none
+
+def Contract.ixMetadata (contract : Contract) : Array (Ix.Name × Ix.DataValue) :=
+  let key := Ix.Name.mkStr (Ix.Name.mkStr Ix.Name.mkAnon "ix") "contract"
+  #[ (key, .ofNat 3),
+     (Ix.Name.mkStr key "kind", .ofNat contract.kindCode),
+     (Ix.Name.mkStr key "code", .ofNat contract.code) ]
+
+/-- Read-only presence scan used to reject optional structural rewrites that
+would remove contracts, including contracts hidden behind sharing. -/
+def containsIxon (sharing : Array Ixon.Expr) (top : Ixon.Expr) : Except String Bool := do
+  let mut seen : Std.HashSet Ixon.Expr := {}
+  let mut stack := #[top]
+  while !stack.isEmpty do
+    let e := stack.back!
+    stack := stack.pop
+    if seen.contains e then continue
+    seen := seen.insert e
+    if (ofIxon? e).isSome then return true
+    match e with
+    | .share index =>
+      let some value := sharing[index.toNat]? | throw "semantic scan: invalid sharing index"
+      stack := stack.push value
+    | .app f a => stack := stack.push f |>.push a
+    | .lam _ t b | .all _ _ t b => stack := stack.push t |>.push b
+    | .letE _ t v b => stack := stack.push t |>.push v |>.push b
+    | .prj _ _ v => stack := stack.push v
+    | _ => pure ()
+  return false
+
+end Ix.SemanticContract
+
+end
diff --git a/Ix/Sharing.lean b/Ix/Sharing.lean
index 15c7a85e0..24b0e6c8d 100644
--- a/Ix/Sharing.lean
+++ b/Ix/Sharing.lean
@@ -51,62 +51,32 @@ def tag0EncodedSize (value : UInt64) : Nat :=
 def tag4EncodedSize (size : UInt64) : Nat :=
   if size < 8 then 1 else 1 + size.byteCount.toNat
 
-/-- Compute the sharing hash for an expression node given its child hashes.
-    This is the single source of truth for sharing hash computation.
-    MUST match Rust's `hash_node` exactly for hash compatibility. -/
+/-- Canonical scalar/contract bytes, followed by fixed-size child hashes.
+    This grammar agrees with Rust's structural sharing hash. -/
+def putNodeHeader : Ixon.Expr → Ixon.PutM Unit
+  | e@(.sort _) | e@(.var _) | e@(.ref ..) | e@(.recur ..) |
+      e@(.str _) | e@(.nat _) | e@(.share _) => Ixon.putExpr e
+  | .prj idx field _ => do
+    Ixon.putTag4 ⟨Ixon.Expr.FLAG_PRJ, field⟩
+    Ixon.putTag0 ⟨idx⟩
+  | .app .. => Ixon.putTag4 ⟨Ixon.Expr.FLAG_APP, 1⟩
+  | .lam contract .. => do
+    Ixon.putTag4 ⟨Ixon.Expr.FLAG_LAM, 1⟩
+    Ixon.putBinderContract contract
+  | .all contract result .. => do
+    Ixon.putTag4 ⟨Ixon.Expr.FLAG_ALL, 1⟩
+    Ixon.putU8 (Ixon.packAllContract contract result)
+  | .letE contract .. => do
+    Ixon.putTag4 ⟨Ixon.Expr.FLAG_LET, contract.flags⟩
+    Ixon.putBinderContract contract.binder
+
 def computeNodeHash (e : Ixon.Expr) (childHashes : Array Address) : Address :=
-  let buf := ByteArray.emptyWithCapacity 100
-  let buf := match e with
-    | .sort univIdx =>
-      buf.push Ixon.Expr.FLAG_SORT |>.append (uint64ToBytes univIdx)
-    | .var idx =>
-      buf.push Ixon.Expr.FLAG_VAR |>.append (uint64ToBytes idx)
-    | .ref refIdx univIndices =>
-      let base := buf.push Ixon.Expr.FLAG_REF
-        |>.append (uint64ToBytes refIdx)
-        |>.append (uint64ToBytes univIndices.size.toUInt64)
-      univIndices.foldl (fun buf idx => buf.append (uint64ToBytes idx)) base
-    | .recur recIdx univIndices =>
-      let base := buf.push Ixon.Expr.FLAG_REC
-        |>.append (uint64ToBytes recIdx)
-        |>.append (uint64ToBytes univIndices.size.toUInt64)
-      univIndices.foldl (fun buf idx => buf.append (uint64ToBytes idx)) base
-    | .prj typeRefIdx fieldIdx _ =>
-      buf.push Ixon.Expr.FLAG_PRJ
-        |>.append (uint64ToBytes typeRefIdx)
-        |>.append (uint64ToBytes fieldIdx)
-        |>.append childHashes[0]!.hash
-    | .str refIdx =>
-      buf.push Ixon.Expr.FLAG_STR |>.append (uint64ToBytes refIdx)
-    | .nat refIdx =>
-      buf.push Ixon.Expr.FLAG_NAT |>.append (uint64ToBytes refIdx)
-    | .app _ _ =>
-      buf.push Ixon.Expr.FLAG_APP
-        |>.append childHashes[0]!.hash
-        |>.append childHashes[1]!.hash
-    | .lam uses _ _ =>
-      buf.push Ixon.Expr.FLAG_LAM
-        |>.push uses.toBits
-        |>.append childHashes[0]!.hash
-        |>.append childHashes[1]!.hash
-    | .all uses owned _ _ =>
-      buf.push Ixon.Expr.FLAG_ALL
-        |>.push (uses.toBits ||| (owned.toBits <<< 2))
-        |>.append childHashes[0]!.hash
-        |>.append childHashes[1]!.hash
-    | .letE nonDep _ _ _ =>
-      buf.push Ixon.Expr.FLAG_LET
-        |>.push (if nonDep then 1 else 0)
-        |>.append childHashes[0]!.hash
-        |>.append childHashes[1]!.hash
-        |>.append childHashes[2]!.hash
-    | .share idx =>
-      buf.push Ixon.Expr.FLAG_SHARE |>.append (uint64ToBytes idx)
-  Address.blake3 buf
+  Address.blake3 <| childHashes.foldl (fun bytes h => bytes ++ h.hash)
+    (Ixon.runPut (putNodeHeader e))
 
 /-- Compute the sharing hash of an expression recursively (for testing).
     Uses computeNodeHash as the single source of truth. -/
-partial def computeExprHash (e : Ixon.Expr) : Address :=
+def computeExprHash (e : Ixon.Expr) : Address :=
   let childHashes := match e with
     | .sort _ | .var _ | .ref _ _ | .recur _ _ | .str _ | .nat _ | .share _ => #[]
     | .prj _ _ val => #[computeExprHash val]
@@ -129,35 +99,7 @@ structure SubtermInfo where
 
 /-- Compute the base size of a node (Tag4 header size) for Ixon serialization. -/
 def computeBaseSize (e : Ixon.Expr) : Nat :=
-  match e with
-  | .sort univIdx =>
-    if univIdx < 8 then 1 else 1 + univIdx.byteCount.toNat
-  | .var idx =>
-    if idx < 8 then 1 else 1 + idx.byteCount.toNat
-  | .ref refIdx univIndices =>
-    -- Tag4 for size + Tag0 for refIdx + Tag0 for each universe index
-    tag4EncodedSize univIndices.size.toUInt64
-    + tag0EncodedSize refIdx
-    + univIndices.foldl (fun acc idx => acc + tag0EncodedSize idx) 0
-  | .recur recIdx univIndices =>
-    -- Tag4 for size + Tag0 for recIdx + Tag0 for each universe index
-    tag4EncodedSize univIndices.size.toUInt64
-    + tag0EncodedSize recIdx
-    + univIndices.foldl (fun acc idx => acc + tag0EncodedSize idx) 0
-  | .prj typeRefIdx fieldIdx _ =>
-    let tagSize := if fieldIdx < 8 then 1 else 1 + fieldIdx.byteCount.toNat
-    let refIdxSize := if typeRefIdx < 128 then 1 else 1 + typeRefIdx.byteCount.toNat
-    tagSize + refIdxSize
-  | .str refIdx =>
-    if refIdx < 8 then 1 else 1 + refIdx.byteCount.toNat
-  | .nat refIdx =>
-    if refIdx < 8 then 1 else 1 + refIdx.byteCount.toNat
-  | .app _ _ => 1  -- telescope count >= 1
-  | .lam _ _ _ => 2
-  | .all _ _ _ _ => 2
-  | .letE _ _ _ _ => 1  -- size encodes non_dep flag
-  | .share idx =>
-    if idx < 8 then 1 else 1 + idx.byteCount.toNat
+  (Ixon.runPut (putNodeHeader e)).size
 
 /-- Get the memory address of an expression for identity-based caching.
     This is safe because we only use it within a single analysis pass
@@ -438,6 +380,7 @@ def rewriteWithSharing (e : Ixon.Expr)
       .letE nonDep (rewriteWithSharing ty hashToIdx ptrToHash)
         (rewriteWithSharing value hashToIdx ptrToHash)
         (rewriteWithSharing body hashToIdx ptrToHash)
+
 termination_by e
 
 /-- State threaded while sharing-vector entries are built. -/
diff --git a/Ix/Tc/Egress.lean b/Ix/Tc/Egress.lean
index c8f0ca312..b0dfe18d7 100644
--- a/Ix/Tc/Egress.lean
+++ b/Ix/Tc/Egress.lean
@@ -189,7 +189,7 @@ def kexprToIxon (root : KExpr .anon) : EgressM Ixon.Expr := do
       let body := values.back!; values := values.pop
       let val := values.back!; values := values.pop
       let ty := values.back!; values := values.pop
-      values := values.push (.letE nd ty val body)
+      values := values.push (.leanLet nd ty val body)
     | .prjDone refIdx field =>
       let val := values.back!; values := values.pop
       values := values.push (.prj refIdx field val)
@@ -397,9 +397,9 @@ end CanonM
 inductive CFrame where
   | process (e : Ixon.Expr)
   | appDone
-  | lamDone (uses : Ixon.Uses)
-  | allDone (uses : Ixon.Uses) (owned : Ixon.Owned)
-  | letDone (nd : Bool)
+  | lamDone (uses : Ixon.BinderContract)
+  | allDone (uses : Ixon.BinderContract) (owned : Ixon.ValueContract)
+  | letDone (nd : Ixon.LetContract)
   | prjDone (refIdx field : UInt64)
   | memoShare (idx : UInt64)
   deriving Inhabited
@@ -409,9 +409,9 @@ inductive CFrame where
 private inductive CFrameP where
   | process (e : Ixon.Expr)
   | appDone
-  | lamDone (uses : Ixon.Uses)
-  | allDone (uses : Ixon.Uses) (owned : Ixon.Owned)
-  | letDone (nd : Bool)
+  | lamDone (uses : Ixon.BinderContract)
+  | allDone (uses : Ixon.BinderContract) (owned : Ixon.ValueContract)
+  | letDone (nd : Ixon.LetContract)
   | prjDone (refIdx field : UInt64)
   | memoShare (idx : UInt64)
   | memoPtr (key : USize)
diff --git a/Ix/Tc/Ingress.lean b/Ix/Tc/Ingress.lean
index 33999c741..b7c7b11e8 100644
--- a/Ix/Tc/Ingress.lean
+++ b/Ix/Tc/Ingress.lean
@@ -6,6 +6,11 @@ public import Ix.Ixon
 /-!
 Mirror: crates/kernel/src/ingress.rs (the Ixon → kernel, anonymous-mode half)
 
+This is the **erased typing** boundary. V3 contracts are retained in the
+addressed source but erased for Lean kernel typing. Resource promises require
+`Ix.Resource.Validate`; successful ordinary typechecking alone establishes
+none of those promises.
+
 Anon ingress uses only `Ixon.Constant` data — never `ConstantMeta`,
 `Env.named`, or `Env.names`. Projection addresses are reconstructed
 deterministically from `(block, idx, [cidx])` via `serConstant` commitment,
@@ -303,8 +308,8 @@ def ingressExpr (ixonEnv : Ixon.Env) (ctx : IngressCtx) (root : Ixon.Expr) :
       | .all _ _ ty body =>
         stack := stack.push .allDone |>.push (.process body)
           |>.push (.process ty)
-      | .letE nd ty val body =>
-        stack := stack.push (.letDone nd) |>.push (.process body)
+      | .letE contract ty val body =>
+        stack := stack.push (.letDone contract.nonDep) |>.push (.process body)
           |>.push (.process val) |>.push (.process ty)
       | .prj typeRefIdx field val =>
         let some typeAddr := ctx.refs[typeRefIdx.toNat]?
@@ -601,3 +606,4 @@ end Ix.Tc
 
 end
 end
+
diff --git a/Ix/Tc/IngressMeta.lean b/Ix/Tc/IngressMeta.lean
index 1e9533ba6..0d86894f9 100644
--- a/Ix/Tc/IngressMeta.lean
+++ b/Ix/Tc/IngressMeta.lean
@@ -561,14 +561,14 @@ def ingressExprMeta (ixonEnv : Ixon.Env) (ctx : IngressMetaCtx)
           |>.push (.process body bodyArena)
           |>.push (.binderPush name)
           |>.push (.process ty tyArena)
-      | .letE nd ty val body =>
+      | .letE contract ty val body =>
         let (name, tyArena, valArena, bodyArena) ← match node with
           | .letBinder nameAddr tyChild valChild bodyChild =>
             pure (resolveName ixonEnv nameAddr, tyChild, valChild, bodyChild)
           | _ => do
             let n ← synthName
             pure (n, currentIdx, currentIdx, currentIdx)
-        stack := stack.push (.letDone name nd mdata)
+        stack := stack.push (.letDone name contract.nonDep mdata)
           |>.push .binderPop
           |>.push (.process body bodyArena)
           |>.push (.binderPush name)
@@ -958,3 +958,4 @@ end Ix.Tc
 
 end
 end
+
diff --git a/Ix/Tc/Primitive.lean b/Ix/Tc/Primitive.lean
index 026479be2..e100cebe6 100644
--- a/Ix/Tc/Primitive.lean
+++ b/Ix/Tc/Primitive.lean
@@ -132,99 +132,99 @@ def h (hex : String) : Address :=
     `eagerReduce` is intentionally not a compiled Lean content hash — see the
     module doc. -/
 def canonical : PrimAddrs where
-  nat := h "1dfffde48c4ef6653b95ecc5474dee8b99461008d26d80ca384f1e59e927714d"
-  natZero := h "50e5d69d806bc1c616cace4230c982a0ee5b350b3efe3b1a15801df77fc00c8c"
-  natSucc := h "8c09ca644b10decad158d37006e81cdc1b84761312260546449aa02e343b2b0c"
-  natAdd := h "f9ac92a11388a7cdca229a8024208554feb32d6c0a3af74a7bc12c28b949543c"
-  natPred := h "fce916cf3c6dd01ad8c6d38641bca7b3eeac5bc93b3529ad7812768b3407d64e"
-  natSub := h "df38352ffa1d6e292349259f33eb678024bb646b358638a02da1995ed4abeb09"
-  natMul := h "f38d4f7baaa021e3b555312145d9ffd3ddc5eacb7bfd5b86a7b0eafdfcf416aa"
-  natPow := h "68f61ef55b63cd23ad8ed185b7eec3dc754e61cc58056087a97e819d0e95e6fd"
-  natGcd := h "ad47f2bbe891b825c48a278f9a0d72997b78baac79891ca6651988b7c9b47f03"
-  natMod := h "f6eb742996c60f1068c2d437afdd8b3609040d64eec5e15f07a11dc11d070d7b"
-  natDiv := h "23173649a58ea5095d1c51a21c7ad2cf8e8dccef342698e07e241668ff7ad3e7"
-  natBitwise := h "85a6fefff63e96a963ef8406d394ab39992323a0ff4530e134a94d46e3a7ba4d"
-  natBeq := h "72c6d4a3b653798850a9ed57018b87ceee0e34195c0902858fd41f6f0e9962ae"
-  natBle := h "c37f2e811f44d59c07094947146ffcbd3aec5ec7002ac3c48ebdebcd83d4688e"
-  natLand := h "8f475cc72da2ac6ce2a9282b6b5df4ccf7bc3cee0649d22766bebd32d1806f3b"
-  natLor := h "8f3c1c432c598e4240d36f8945942174675c5c91e03f6b8ab018e8b052622c63"
-  natXor := h "800a8a2d6f91bd1a91d313d1e19ef69f37dedd07f7de4f929780be855a03fd1f"
-  natShiftLeft := h "5473592e707943ec072a2ee53c433da2c77aa45ed634da54b24374d19eb90cd2"
-  natShiftRight := h "1b591149158d896937eebfd53232b5ae8a4bcdb25a6811c96bd94114a9f8bed5"
+  nat := h "35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc"
+  natZero := h "eeb2e6268ff6d0e6b2e9764d9940b81bb64b9f8f4b1358d294ff9817e6941a46"
+  natSucc := h "42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6"
+  natAdd := h "724db797e1817545a08371432fd1fa6428a37dcf9c1671df7e464849db0a81ac"
+  natPred := h "76afa254a8bbf2ac4327d7b94be0c63bd708836b5f7384ce990388adb0a1d3cf"
+  natSub := h "9de2d2c60e7d421a2fdfb8706e91e0e6d8576c3bd46ec00405c65875cb9b5a26"
+  natMul := h "566a3c2249bc2076543d9bc561a841f6fd35ffb5bdbbc5c991a9c64feccbd5d4"
+  natPow := h "5ba43ac3e5d29fe5ce81f18a18178a2705c37ee674b9b6ee50e9466a86593b15"
+  natGcd := h "76007dcf8b285cdbd6f779012290fe2e6afd221ce8821082a7e2ef81e8d815cf"
+  natMod := h "e6ffe78713d4b974a82d0187538f1a0cf5c4b260f0fd99264fab263b1af847f9"
+  natDiv := h "c075ed976f1702f364fb0bb34aa8bbc166adace573f2ce914b43dc4f4aab6219"
+  natBitwise := h "aaf7df6a1f024f580fde236cba16235f071d1b796cc279faf43178d22b5ae36d"
+  natBeq := h "ffd3f02a19fda649aa5608ed818db382e160231b76d5b09176d7dd1a8d5b1ec5"
+  natBle := h "68a3643ec69816aec107302ddbfa054cebcd3ec173cd5f7e6d883638631afe65"
+  natLand := h "c61fad46a102dbff5922312d4fbe6e704ec3c62c6c6f64b3d481b78c77cf315d"
+  natLor := h "cb7dccc020a530fed7c622b100ee52c1078b5018159ba4682f817e3776789ee8"
+  natXor := h "d8a6b05a1a4e5cadc69c53792e8e130314745e76e32bb30a9ce0272fa079e8a6"
+  natShiftLeft := h "5c15f98e2bd9c257bcdfac62b0043a2e3e2bbdff8b210f104b5c3739e862ac0c"
+  natShiftRight := h "3f92725324b09fa75c6fcd16da863671428ff33b7db667eb760e1cd503a2bcad"
   boolType := h "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4"
   boolTrue := h "a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762"
   boolFalse := h "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e"
-  string := h "4288f92ed1d51f4935e5d2775f33ec585d6fe5ec63dadf0ea698554478fd9fad"
-  stringMk := h "d54db71fee55311aafeead74768e6e952262c29abd24b9319fa6859481dd44b8"
-  charType := h "d55429725a19c1837b34624fb35784b91bc8b0e2d79f98b3c296317fb6c5c789"
-  charMk := h "7b443f2f10fd4b2fb88b59e90f1a04b46552f73ea2e8f26d77290b7ae63dd531"
-  charOfNat := h "29563da271c23f66b27d05f924fb0612272dcfba6b1083b348733e00f9b36b2a"
-  stringOfList := h "d54db71fee55311aafeead74768e6e952262c29abd24b9319fa6859481dd44b8"
-  stringToByteArray := h "ad700c0806e673e74adcafc28ca659d30a616633a4a36420324fc29eae69eb9c"
-  byteArrayEmpty := h "d838bb6bb651533081ac2495a25d690c54f8e345fff41efbd5585eb468705308"
-  list := h "ae8d736dd3fcc89dc3f9d66aa54bed4ad8607fb9d4843f4c8736591dd0c9e000"
-  listNil := h "3c0149c3432969ee5d9354c8d2d89ceec4a79711f8dec8710879a12a12b72c42"
-  listCons := h "d1e0802c38bcda14061e2012f12e73c2a24a671137984f8ef76744ea04d188c4"
-  eq := h "b20ea17ba3d9723f0bd06457d9cf48ce26ca36619b946980627de923873e9595"
-  eqRefl := h "e308035bdf280c927556824d6a9f9236a1487651f0059a7df3bda85b331f67e6"
-  quotType := h "e775aa31759a9d4acdbc2b8519ff73f57552bb0cba4daf1659bba00f6a931b4b"
-  quotCtor := h "0a4cc7c930dd6726bbd7f1bc3fea685df5f666549d651d3e766fe5746ec459a4"
-  quotLift := h "560276f95e0d93e27b8c05097995bf82876332c2e7e31033e0a194819e4e8d30"
-  quotInd := h "02f358808fd4328d74850582d3608d2d31e49519b4c6c66b3605fbe6f42d3c5d"
-  reduceBool := h "d4d775ceff37ab7a402416118f1d2ce5b9e7f2143d0c3dc8fe5431571df3260c"
-  reduceNat := h "2075bda5457b299b27246770c8416273686bbf627aa6a01ac413a27e583eb95d"
+  string := h "9d6ae43429ec02a9338bbcd0db0ac193d75ebd46f884bfcbd2c42bf7faea150d"
+  stringMk := h "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2"
+  charType := h "4c59bc4eac82d31ebed59bb206909dbded65b92fd56de2518fcdadb0a42c11a0"
+  charMk := h "82e09601422cae23b0b6df9922abb9f0b014e20047a00a7ab96871dd7da3e5ac"
+  charOfNat := h "caf51b039d71cfce7063e106064f9435f5337bbc42567c8c78b5f66c7f087920"
+  stringOfList := h "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2"
+  stringToByteArray := h "79862acfbc2e37b7b6122143f0a6a51114c34fa483ff14146483de18835d4209"
+  byteArrayEmpty := h "bf58e6cb3aa0f746850629041635cd30c0ad66262b6617660f2290241f08b08b"
+  list := h "4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01"
+  listNil := h "3994bc51e3686f30a1d483d69d0a835a7b484d892393c084f87a5849de54f302"
+  listCons := h "b3a7d80249fd823100ee03626232d1412a0e8335275d5df53b92943887b650f7"
+  eq := h "c37d6290e00fb865fb5db7bce18fd69e6d1674ad573724b85466ea9f7578a207"
+  eqRefl := h "d494dc601386ba8e8f0b711fe62a2d60ab60c6488c8cf6ce97796ebc3ad5fefb"
+  quotType := h "45040b3126855169dad919a970a9c72cee5875658aedb3bd1f89fcdf8c88edfa"
+  quotCtor := h "811600dfa59f3612cb03c0f0475af152399defff9226c6e19fd648041a6899a9"
+  quotLift := h "86b365e75bb4230f04c6e4f3a7ca6988adf574616d79a3d7477ad65cac102110"
+  quotInd := h "1745491c0d651de0bea589d5fffbc9bc4d7fbe897c1d805b1f7f59ca9696a6ef"
+  reduceBool := h "bacc4c814a4572ddfd969a1857adfe18239eb6bd8b1627ee79744a6a9b23b030"
+  reduceNat := h "b6327d9a1bbb461a447f0c971e622dd9a35132bd7de75bf69e20794d7a0e8595"
   eagerReduce := h "ff00000000000000000000000000000000000000000000000000000000000003"
-  systemPlatformNumBits := h "5060a22df86307dd8bbe656e13868f3a1618e7a0d880b8cbb00759cffd31800d"
-  systemPlatformGetNumBits := h "80f975ded9d6ab7095e9db2ed1cfa6f5c35eafe5c56990e2c1321b02c5664e6c"
-  subtypeVal := h "7e4e9b33b696a7d3fce1745dfb5fbeeb938fc8882a82bee15723e0d253e59158"
-  natDecLe := h "2999801598c1da48f562d4836064f635c045d0521452b5e74a12bf99d2e316ec"
-  natDecEq := h "1bac041756ed22d73bbcac849a94f246ee2696999faf351940468d962970ca2a"
-  natDecLt := h "12f386f486913b11b5473cb2538330d51f25aeec7f2d7d6b96904329c78b6967"
-  decidableRec := h "6af73809a6128adcb9c5d7e73a30c28d489dba4d905717055ac2edd755ffa713"
-  decidableIsTrue := h "7b3f6a6eebf32a9d5a54305e693dce60511afeb1fa11bc8844a5c21bbfd3214c"
-  decidableIsFalse := h "ab1470196419f71d06feed9ccb8c1d03674528ec03012b095badc169d48d03d0"
-  natLeOfBleEqTrue := h "23bea3bbf3a8d0a8d0033cf7e56af0c4aee01582d5a758c0df5615929ca6204d"
-  natNotLeOfNotBleEqTrue := h "be50b6053df0b07438a4ac2eefd70a11708b0cbb0fc90564bafee6e165615de8"
-  natEqOfBeqEqTrue := h "c489329197b59a040d1e5e4d5de6a770478d1ea4f9750176026dd2bf8593bf22"
-  natNeOfBeqEqFalse := h "0eb5b987f12124be0575a477cc0a535516a24b0ae5ceddbee2d472765aed299c"
-  fin := h "a7e9a8b84a2fe96cc204acc93d7ed1366d9d0574aaf0f09633d2b09a94c9e860"
-  boolNoConfusion := h "99e7eaac2b27ffae4adc4902f8965520ee696c662438f10169cf36c8ad4cc4e5"
-  int := h "fb2bd9d8fb7c3cc603bc021dcdbc5c6aa3ae80688b7d2e85ab18fa336ccc04ba"
-  intOfNat := h "48786b7f7adc632ae35059f3fd181df32d9e5cc7360c4fd02c3e8b1181a1539b"
-  intNegSucc := h "cfc934fd6d53a5b23b6a3b30d02165fdaa574e3b5eb13926bb166e6486fc0e50"
-  intAdd := h "1e60bd377a746cb7bd7ae541d7dfb237097d883d28ec7aadd732c0674e0db964"
-  intSub := h "0d74ba85f9749a0c25aa6a2b70348e57e709831fb7cc05229fecd7d66adf184d"
-  intMul := h "c5bef6be6c3fdc520454c11e9950eb2f1a6c92f41a646b5ca168ff198f13c55a"
-  intNeg := h "bc61c10fcca6415223ed97bcae21cb99d4836d077b0786a2fc5c5905f8b04ba2"
-  intEmod := h "d435a15e6f222f786b6130fa764c7fbe98746f798e97a627a6237a17e74f7227"
-  intEdiv := h "3e13fc1a077eb692af40acbed4a6adae255c0cbbba9a3c1f0de29573b197cb0e"
-  intBmod := h "9970f402c870e8a3146fbf4b76f949aa64b206de9b0157b469fde357b715f19c"
-  intBdiv := h "867f8e9dfb752265ba4742368b6afa546ae4e240fc5ac69b4a4e86d85a6e46f6"
-  intNatAbs := h "21d4dacc0f406b31e044fbf4d8987a332dd8b4244f7d9e62b086501474825544"
-  intPow := h "878599e9f5bbccb942232ff93b62c63db4ebdf62b9f9237900a37049f422ad86"
-  intDecEq := h "7a06496d07b59710348a5f657851a4eea1f59492a5b7de3f51abbc84f9bc1d17"
-  intDecLe := h "14eccee1deba05e9443bd169d00ed634170e3246b37921199edbbad3f67db5b4"
-  intDecLt := h "ad32c05d7e3c5ddf4e4c85cf8f60d83e0fba55e2676bf8a1e608db54b167c9fa"
+  systemPlatformNumBits := h "6f620654d341990a301387b80ef75b1e0b6130ddf19164025b6dc37bf3c3dc18"
+  systemPlatformGetNumBits := h "00c266834f9039931b4be2fac5584cd176a0ae7ee4cb4064ddb5e04dd12b6cbb"
+  subtypeVal := h "ea65f517457fae9b705299da08b0d3c8cf9a476f16470cca5cae5ea7bd238230"
+  natDecLe := h "f0f15ed079822f06e82e36664bf61e797e5b1e7b0b4155152762c513274bfee1"
+  natDecEq := h "8a5d5eee414a2fa5956b74e8323a20508d774ed1b5603f55e774ad896bd3e6e7"
+  natDecLt := h "7c4977196e95be2a759fc9c6d1533db8da49592f06419b155d888333c8dd8931"
+  decidableRec := h "16cfddda9c274660f391b10eefe066275afffae1ccd49c6daf43afb8a80aea85"
+  decidableIsTrue := h "363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da"
+  decidableIsFalse := h "8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b"
+  natLeOfBleEqTrue := h "ad25bfd207bae832c73d5ce614bead22ef9862e110f8d17a5064ffb7603eee3d"
+  natNotLeOfNotBleEqTrue := h "e3658f50dc5123efff213588dee3d4c6063f5edb18950850ac0490c937819009"
+  natEqOfBeqEqTrue := h "9c91e79de732226ba2e73cbdd330851baec40668eb40c6f32aa2f8dac5a04b51"
+  natNeOfBeqEqFalse := h "a07db532747e65ee77a7ba015069bdbaf1f709ce0d60b83c94f40d0e5e57595a"
+  fin := h "3d79797bc572d8f33eb7cff5aa13f8dc73bcf21026bf05d03888c9aa0369dcef"
+  boolNoConfusion := h "de7b523cc4470e15328a01d935988861dadf9bd012240400464dea8c79a9dfe2"
+  int := h "c60c95e3cdbf4ed010d999b3277f4e1fd3695e8c30260876102905d7b36241a2"
+  intOfNat := h "0a99f49cc73ab9f42783092e7120613225670bab89b9d63533d1adefc876182f"
+  intNegSucc := h "f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc"
+  intAdd := h "9db0177e4e8b6a0e7323069509c2457de9598a7e38e72ffe19ad34617256e10d"
+  intSub := h "85621387ef3027028d835287f3cc1461ef041def1fd91e28e87f669cc04a5eea"
+  intMul := h "b05459623d23299d3a849eb7fb75badbc1547a1cd9ee560c15067fbd985c6cea"
+  intNeg := h "6701d765ff10bfa3a6c347df15194e0db862ee25b54f25a59f7cf21951a3997e"
+  intEmod := h "e29cfa7921bb57f4782b021c977596a4fae04e94f7b07955fe2814fc48de90e7"
+  intEdiv := h "9c952d45a3bd43161529fcfb5e276beab0cf4fd64a01ba9bc2c7cda376cb8f54"
+  intBmod := h "0b1564dea6ffcd204ebcd1aa69d29ee6f3acccd87bd146ff674556ac9cc8ccb3"
+  intBdiv := h "6d35dc43660f6c509a13f2824c027ed99ab070a08f058ff0a5f46a759250797d"
+  intNatAbs := h "261ae54edb66e900784a64350bc01e8b3fe1332a47caeab58e0361dffc7ea008"
+  intPow := h "87266415982bbdec50c61dec5b73cc0ccd5c997445997a9724a1cc5c2e39d3a4"
+  intDecEq := h "fc8c44cc970cfc183ccd10a2d1cdeb2c849307760e91f5cd29a2b02f706d83da"
+  intDecLe := h "fcdf1860ad4cd672239392e60e7b49e024af0475739c3a40195a914eaec42c04"
+  intDecLt := h "1d54806ab1ebc791e1db96e88d0407cef3523927d60ba669689b92a8eeb36445"
   punit := h "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b"
-  pprod := h "7eac420873e8f1ea8fe66831a6c6f69d88693bed6aeb30bfba82069af60ebea8"
-  pprodMk := h "f3993d287c47b81c9e0902aa91d227650f6f4e55b3a1c63a87f283b4ed9e418e"
-  natRec := h "89d6690b0808b1da49e015a4f21df3fc3f00fb96ac502f5f097ce452e573704c"
-  natCasesOn := h "b2f8855b5e76a480493cd6cc922977e60723b4bec665dd7e9b73ca2b215df576"
-  bitVec := h "c7192ac507d67c3c3e1eb90633858ae7b7cbc80e3988312618c7ec09b483b04a"
-  bitVecToNat := h "acd9f0a3f7e8c53a46b91759358366fa028240b0b6cc09205dde34a33544678d"
-  bitVecOfNat := h "5721ca2acf2c6994771509332fb185f783f442aefce417d2863e2d148edcdb8a"
-  bitVecUlt := h "8d57c7c6aee1ba510d3208ddc4b08a83b44319f6af8ee09b3940d0ddedce1eb6"
-  decidableDecide := h "d1107c99ad9ebcb5028d9aea0da521ed5c12e71ea2ecdeaf637bb4a14d4a7e44"
-  ltLt := h "c69df4833ecdce76bdb0d23159e1fac652d88919768c312c6611dc060da16f04"
-  ofNatOfNat := h "c68bfa47519ff72b1d053b86e6e3b7356286eb2252616cc5b2acbed59ef1f5f0"
+  pprod := h "90ca5bcf995d68d7dfcb3c7cfe466986dc4beaa402b262ca395b3e53c36f6cad"
+  pprodMk := h "ce30fc0f4135e679cf3b16d0d667bd9df4e7a69dbb8177a29e5c75b48c4cec10"
+  natRec := h "d1053449c217e5cc6fc29b2cb59cfd5ead385d392d00ada2221d4000dda7def3"
+  natCasesOn := h "c575abb02efd158091356aa793c809c0570f8a24a8a777f206a95b9ce0b88855"
+  bitVec := h "7f0f5feda1828072123f242a46a40549e85934f7395e4f93f65dda4e4809f325"
+  bitVecToNat := h "c110d614b441c6cca69ecd7c1c2c76f3bc21fd40c4001e6a1a7d1cf481e23cdd"
+  bitVecOfNat := h "29b9f24086b1b1f88211358866139fdb7dcdfc97b5f6c77fc495bf8c77639982"
+  bitVecUlt := h "9301d850bde246940b7b3e81e786f7f12bae8e5cea6b3f4040060b3a7f59557c"
+  decidableDecide := h "20e8906280b4dcd74a7a78e06d580e6f00eebba9fc40789262e95cacb6f0d699"
+  ltLt := h "4802b183f4d6dcccacba57721824a7bb67daeb2725da17239271c135952caa61"
+  ofNatOfNat := h "a99dedbb1676866aed829c3d4bba86a37e98ec62a35834389c32937e4e2b1a4a"
   unit := h "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb"
-  punitSizeOf1 := h "84fe3d0f08f0651a6f0936a9a0f18e4f0dace169ac4233bf1adad05d6e078a25"
-  sizeOfSizeOf := h "78f38887f6bbe54339ecec6b3c5f66856de7baa530378d2d9065bfe2daf4b801"
-  stringBack := h "3f92a46a1451fd66215aae9cf789ce38a2c73fdd55909d454f61259634d90b6b"
-  stringLegacyBack := h "a2a310133d17371af67cd91d279aaf735fa8cb810c39aaa824a443c652e3df66"
-  stringUtf8ByteSize := h "b1f6f04bde3d81f9102ea6b7d2c9f4236d72b17e01125523c5d5e261afc71105"
-  stringAppend := h "b6ec2d443f3ee61de45ad859b8cc41a896d8fba49bc29883fc34c427dbdf71f8"
-  stringDecEq := h "d616327d4fc219bd7114bad46cd0866befe2551518b5bf2e10b5cac93381fb77"
+  punitSizeOf1 := h "e85bf516c76cadd8ce1fdab3cc94ed685e47be3c7a8b52f53fe2b3502e6f70c7"
+  sizeOfSizeOf := h "402b71bcccf0be0315f1bda6bdbb20e559e31704617d3eaccb05d5c5fe03b53d"
+  stringBack := h "32104b03348d11acb2437fda24966dc58cc8c8bcca96582614e644d319a42c62"
+  stringLegacyBack := h "37ef5fee765dc2e5c7425c180cd42007db7d29ae0d5c091789f462f2805b0e09"
+  stringUtf8ByteSize := h "52b0226ea14c94b1f9334c9957f5589399a86bcdae111f2847c9b0c2fb0a2261"
+  stringAppend := h "132f1175cc3cac5a3e3d74e8797f9ba67f2e467b8004a3f28bb5dfd16a3647b1"
+  stringDecEq := h "19134fdc188e8377d0173857e15d3b5065ed76da981397107e5c404db3f3b718"
 
 /-- The synthetic kernel-only marker address used by the *original*
     (LEON-addressed) environment's `PrimAddrs::new_orig()`. Only the marker is
@@ -597,3 +597,4 @@ end Ix.Tc
 
 end
 end
+
diff --git a/Ix/Tc/Verify/Driver/BooleanAcceptance.lean b/Ix/Tc/Verify/Driver/BooleanAcceptance.lean
index a10caebea..7c773fe85 100644
--- a/Ix/Tc/Verify/Driver/BooleanAcceptance.lean
+++ b/Ix/Tc/Verify/Driver/BooleanAcceptance.lean
@@ -8,9 +8,8 @@ This module connects the concrete E2 Boolean generation certificate to the
 E3-S production-driver adapter.  The runtime checker call remains a required
 gate, but semantic authority for these two coordinated blocks comes from the
 fixed family transition and existing-recursor certificates.  In particular,
-the proof does not reinterpret the runtime cache order as a topological
-semantic schedule: the recursor work item is physically enumerated first,
-while its successful checker call also validates and caches the family block.
+the proof supplies a topological semantic schedule independently of runtime
+cache order. The v3 address order enumerates the family before its recursor.
 
 The staged baseline below has the constructively generated Boolean Theory
 environment and an empty trust predicate.  Its `VEnv.WF` field is derived
@@ -80,7 +79,7 @@ def familyItem : AnonWorkItem :=
   .block familyBlockAddress familyId.addr
     #[familyId.addr, falseId.addr, trueId.addr]
 
-def booleanWork : Array AnonWorkItem := #[recursorItem, familyItem]
+def booleanWork : Array AnonWorkItem := #[familyItem, recursorItem]
 
 private theorem buildAnonWorkNative :
     buildAnonWork recursorIxonEnv = .ok booleanWork := by
@@ -106,25 +105,25 @@ def recursorProjectionConstant : Ixon.Constant :=
 
 private theorem sourceAddressesNative :
     orderedAnonConstAddrs recursorIxonEnv =
-      #[recursorId.addr, recursorBlockAddress, trueId.addr,
-        familyBlockAddress, falseId.addr, familyId.addr] := by
+      #[recursorId.addr, trueId.addr, familyBlockAddress,
+        recursorBlockAddress, falseId.addr, familyId.addr] := by
   native_decide
 
 theorem sourceAddresses :
     orderedAnonConstAddrs recursorIxonEnv =
-      #[recursorId.addr, recursorBlockAddress, trueId.addr,
-        familyBlockAddress, falseId.addr, familyId.addr] :=
+      #[recursorId.addr, trueId.addr, familyBlockAddress,
+        recursorBlockAddress, falseId.addr, familyId.addr] :=
   sourceAddressesNative
 
 private theorem sourceKeysNative :
     recursorIxonEnv.consts.keys =
-      [recursorBlockAddress, falseId.addr, recursorId.addr,
-        trueId.addr, familyBlockAddress, familyId.addr] := by
+      [falseId.addr, trueId.addr, recursorId.addr,
+        recursorBlockAddress, familyBlockAddress, familyId.addr] := by
   native_decide
 
 private theorem sourceAddressesNodupNative :
-    (#[recursorId.addr, recursorBlockAddress, trueId.addr,
-      familyBlockAddress, falseId.addr, familyId.addr] : Array Address).toList.Nodup := by
+    (#[recursorId.addr, trueId.addr, familyBlockAddress,
+        recursorBlockAddress, falseId.addr, familyId.addr] : Array Address).toList.Nodup := by
   native_decide
 
 private theorem recursorTargetsNonemptyNative :
@@ -140,8 +139,8 @@ is used to classify arbitrary successful lookups, independently of the
 ordering implementation used by `buildAnonWork`. -/
 theorem sourceKeys :
     recursorIxonEnv.consts.keys =
-      [recursorBlockAddress, falseId.addr, recursorId.addr,
-        trueId.addr, familyBlockAddress, familyId.addr] :=
+      [falseId.addr, trueId.addr, recursorId.addr,
+        recursorBlockAddress, familyBlockAddress, familyId.addr] :=
   sourceKeysNative
 
 private theorem familyBlockEntry :
@@ -203,15 +202,15 @@ private theorem sourceEntryCases {addr : Address} {constant : Ixon.Constant}
   · subst addr
     exact .inr (.inr (.inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry recursorProjectionEntry⟩)))
-  · subst addr
-    exact .inl ⟨rfl,
-      ExactAnonEntry.constant_unique hentry recursorBlockEntry⟩
   · subst addr
     exact .inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry trueProjectionEntry⟩)
   · subst addr
     exact .inr (.inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry familyBlockEntry⟩))
+  · subst addr
+    exact .inl ⟨rfl,
+      ExactAnonEntry.constant_unique hentry recursorBlockEntry⟩
   · subst addr
     exact .inr (.inr (.inr (.inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry falseProjectionEntry⟩))))
@@ -231,9 +230,9 @@ def sourceWF : AnonWorkEnvWF recursorIxonEnv where
     simp at haddr
     rcases haddr with rfl | rfl | rfl | rfl | rfl | rfl
     · exact ⟨recursorProjectionConstant, recursorProjectionEntry⟩
-    · exact ⟨recursorBlockConstant, recursorBlockEntry⟩
     · exact ⟨trueProjectionConstant, trueProjectionEntry⟩
     · exact ⟨familyBlockConstant, familyBlockEntry⟩
+    · exact ⟨recursorBlockConstant, recursorBlockEntry⟩
     · exact ⟨falseProjectionConstant, falseProjectionEntry⟩
     · exact ⟨familyProjectionConstant, familyProjectionEntry⟩
   blocksNonempty := by
@@ -338,22 +337,12 @@ def blockOfIdempotent : IxonEnv.BlockOfIdempotent recursorIxonEnv := by
       rw [sourceKeys] at hkey
       simp at hkey
       rcases hkey with rfl | rfl | rfl | rfl | rfl | rfl
-      · simp [blockOfAddr, recursorBlockEntry.getConst,
-          recursorBlockConstant]
-      · simp [blockOfAddr, falseProjectionEntry.getConst,
-          familyBlockEntry.getConst, falseProjectionConstant,
-          familyBlockConstant]
-      · simp [blockOfAddr, recursorProjectionEntry.getConst,
-          recursorBlockEntry.getConst, recursorProjectionConstant,
-          recursorBlockConstant]
-      · simp [blockOfAddr, trueProjectionEntry.getConst,
-          familyBlockEntry.getConst, trueProjectionConstant,
-          familyBlockConstant]
-      · simp [blockOfAddr, familyBlockEntry.getConst,
-          familyBlockConstant]
-      · simp [blockOfAddr, familyProjectionEntry.getConst,
-          familyBlockEntry.getConst, familyProjectionConstant,
-          familyBlockConstant]
+      all_goals simp [blockOfAddr, recursorBlockEntry.getConst,
+        familyBlockEntry.getConst, falseProjectionEntry.getConst,
+        trueProjectionEntry.getConst, recursorProjectionEntry.getConst,
+        familyProjectionEntry.getConst, recursorBlockConstant,
+        familyBlockConstant, falseProjectionConstant, trueProjectionConstant,
+        recursorProjectionConstant, familyProjectionConstant]
 
 /-- Exact collapsed dependency catalog used by the Boolean driver theorem. -/
 def dependencyGraph : DependencyCatalog :=
@@ -410,7 +399,7 @@ theorem depsClosed :
   intro item hitem target hdependency
   rw [expectedAnonWork_eq] at hitem
   have hcases : item = recursorItem ∨ item = familyItem := by
-    simpa [booleanWork] using hitem
+    simpa [booleanWork, or_comm] using hitem
   rcases hcases with rfl | rfl
   · left
     change dependencyGraph.dependsOn recursorBlockAddress target at hdependency
@@ -429,16 +418,15 @@ theorem subjects_disjoint_assumptions :
   intro addr _ haddr
   simp [noAssumptions] at haddr
 
-/-- A semantic schedule may differ from the physical serial enumeration.
-The family is admitted first because every recursor reference collapses into
-that family block; the production driver still executes recursor-first. -/
+/-- The family is admitted first because every recursor reference collapses
+into that family block. This schedule agrees with the v3 address order. -/
 def wellFounded :
     WellFoundedBlocks dependencyGraph (expectedAnonWork recursorIxonEnv)
       sourceWF.subjects where
   schedule := [familyItem, recursorItem]
   permutation := by
     rw [expectedAnonWork_eq]
-    exact List.Perm.swap recursorItem familyItem []
+    exact List.Perm.refl _
   topological := by
     apply TopologicalFrom.cons
     · intro target hdependency _
@@ -459,7 +447,7 @@ def wellFounded :
     intro item target hitem hdependency _ houtside
     rw [expectedAnonWork_eq] at hitem
     have hcases : item = recursorItem ∨ item = familyItem := by
-      simpa [booleanWork] using hitem
+      simpa [booleanWork, or_comm] using hitem
     rcases hcases with rfl | rfl
     · change dependencyGraph.blockOf target ≠ recursorBlockAddress at houtside
       change (if dependencyGraph.blockOf target = recursorBlockAddress then 1 else 0) <
@@ -538,7 +526,7 @@ def supportedFragment :
   resources := by
     intro item hitem before checker hrun current hle hdeps hnot
     have hcases : item = recursorItem ∨ item = familyItem := by
-      simpa [booleanWork] using hitem
+      simpa [booleanWork, or_comm] using hitem
     by_cases hrecursor : item = recursorItem
     · subst item
       exact .block (recursorCertificateResources current hle)
@@ -562,8 +550,8 @@ def checkCfg : CheckCfg :=
   { verifyHashes := true, clearEvery := 1 }
 
 def successfulResults : Array CheckResult :=
-  #[⟨recursorId.addr, none⟩, ⟨familyId.addr, none⟩,
-    ⟨falseId.addr, none⟩, ⟨trueId.addr, none⟩]
+  #[⟨familyId.addr, none⟩, ⟨falseId.addr, none⟩,
+    ⟨trueId.addr, none⟩, ⟨recursorId.addr, none⟩]
 
 private theorem checkEnvAnonNative :
     checkEnvAnon recursorIxonEnv checkCfg = .ok successfulResults := by
diff --git a/Ix/Tc/Verify/Driver/Dependencies.lean b/Ix/Tc/Verify/Driver/Dependencies.lean
index 281c211ea..ba1941e89 100644
--- a/Ix/Tc/Verify/Driver/Dependencies.lean
+++ b/Ix/Tc/Verify/Driver/Dependencies.lean
@@ -39,29 +39,29 @@ inductive DeclReference (sharing : Array Ixon.Expr)
   | appArg {fn arg : Ixon.Expr} {target : Address} :
       DeclReference sharing refs arg target →
       DeclReference sharing refs (.app fn arg) target
-  | lamType {uses : Ixon.Uses} {type body : Ixon.Expr} {target : Address} :
+  | lamType {uses : Ixon.BinderContract} {type body : Ixon.Expr} {target : Address} :
       DeclReference sharing refs type target →
       DeclReference sharing refs (.lam uses type body) target
-  | lamBody {uses : Ixon.Uses} {type body : Ixon.Expr} {target : Address} :
+  | lamBody {uses : Ixon.BinderContract} {type body : Ixon.Expr} {target : Address} :
       DeclReference sharing refs body target →
       DeclReference sharing refs (.lam uses type body) target
-  | allType {uses : Ixon.Uses} {owned : Ixon.Owned}
+  | allType {uses : Ixon.BinderContract} {owned : Ixon.ValueContract}
       {type body : Ixon.Expr} {target : Address} :
       DeclReference sharing refs type target →
       DeclReference sharing refs (.all uses owned type body) target
-  | allBody {uses : Ixon.Uses} {owned : Ixon.Owned}
+  | allBody {uses : Ixon.BinderContract} {owned : Ixon.ValueContract}
       {type body : Ixon.Expr} {target : Address} :
       DeclReference sharing refs body target →
       DeclReference sharing refs (.all uses owned type body) target
-  | letType {nondep : Bool} {type value body : Ixon.Expr}
+  | letType {nondep : Ixon.LetContract} {type value body : Ixon.Expr}
       {target : Address} :
       DeclReference sharing refs type target →
       DeclReference sharing refs (.letE nondep type value body) target
-  | letValue {nondep : Bool} {type value body : Ixon.Expr}
+  | letValue {nondep : Ixon.LetContract} {type value body : Ixon.Expr}
       {target : Address} :
       DeclReference sharing refs value target →
       DeclReference sharing refs (.letE nondep type value body) target
-  | letBody {nondep : Bool} {type value body : Ixon.Expr}
+  | letBody {nondep : Ixon.LetContract} {type value body : Ixon.Expr}
       {target : Address} :
       DeclReference sharing refs body target →
       DeclReference sharing refs (.letE nondep type value body) target
diff --git a/Ix/Tc/Verify/Ingress/SerializedBoolean.lean b/Ix/Tc/Verify/Ingress/SerializedBoolean.lean
index 3d5cdaac7..91ed2c3ea 100644
--- a/Ix/Tc/Verify/Ingress/SerializedBoolean.lean
+++ b/Ix/Tc/Verify/Ingress/SerializedBoolean.lean
@@ -76,31 +76,31 @@ def env : Ixon.Env := IxonEnv.eraseAnonMetadata decoded
 
 private theorem sourceAddressesNative :
     orderedAnonConstAddrs env =
-      #[recursorId.addr, recursorBlockAddress, trueId.addr,
-        familyBlockAddress, falseId.addr, familyId.addr] := by
+      #[recursorId.addr, trueId.addr, familyBlockAddress,
+        recursorBlockAddress, falseId.addr, familyId.addr] := by
   native_decide
 
 theorem sourceAddresses :
     orderedAnonConstAddrs env =
-      #[recursorId.addr, recursorBlockAddress, trueId.addr,
-        familyBlockAddress, falseId.addr, familyId.addr] :=
+      #[recursorId.addr, trueId.addr, familyBlockAddress,
+        recursorBlockAddress, falseId.addr, familyId.addr] :=
   sourceAddressesNative
 
 private theorem sourceKeysNative :
     env.consts.keys =
-      [falseId.addr, recursorBlockAddress, recursorId.addr,
-        trueId.addr, familyBlockAddress, familyId.addr] := by
+      [falseId.addr, trueId.addr, recursorId.addr,
+        recursorBlockAddress, familyBlockAddress, familyId.addr] := by
   native_decide
 
 theorem sourceKeys :
     env.consts.keys =
-      [falseId.addr, recursorBlockAddress, recursorId.addr,
-        trueId.addr, familyBlockAddress, familyId.addr] :=
+      [falseId.addr, trueId.addr, recursorId.addr,
+        recursorBlockAddress, familyBlockAddress, familyId.addr] :=
   sourceKeysNative
 
 private theorem sourceAddressesNodupNative :
-    (#[recursorId.addr, recursorBlockAddress, trueId.addr,
-      familyBlockAddress, falseId.addr, familyId.addr] : Array Address).toList.Nodup := by
+    (#[recursorId.addr, trueId.addr, familyBlockAddress,
+        recursorBlockAddress, falseId.addr, familyId.addr] : Array Address).toList.Nodup := by
   native_decide
 
 private theorem recursorBlockLookupNative :
@@ -220,15 +220,15 @@ private theorem sourceEntryCases {addr : Address} {constant : Ixon.Constant}
   · subst addr
     exact .inr (.inr (.inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry recursorProjectionEntry⟩)))
-  · subst addr
-    exact .inl ⟨rfl,
-      ExactAnonEntry.constant_unique hentry recursorBlockEntry⟩
   · subst addr
     exact .inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry trueProjectionEntry⟩)
   · subst addr
     exact .inr (.inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry familyBlockEntry⟩))
+  · subst addr
+    exact .inl ⟨rfl,
+      ExactAnonEntry.constant_unique hentry recursorBlockEntry⟩
   · subst addr
     exact .inr (.inr (.inr (.inr (.inl ⟨rfl,
       ExactAnonEntry.constant_unique hentry falseProjectionEntry⟩))))
@@ -256,9 +256,9 @@ def sourceWF : AnonWorkEnvWF env where
     simp at haddr
     rcases haddr with rfl | rfl | rfl | rfl | rfl | rfl
     · exact ⟨recursorProjectionConstant, recursorProjectionEntry⟩
-    · exact ⟨recursorBlockConstant, recursorBlockEntry⟩
     · exact ⟨trueProjectionConstant, trueProjectionEntry⟩
     · exact ⟨familyBlockConstant, familyBlockEntry⟩
+    · exact ⟨recursorBlockConstant, recursorBlockEntry⟩
     · exact ⟨falseProjectionConstant, falseProjectionEntry⟩
     · exact ⟨familyProjectionConstant, familyProjectionEntry⟩
   blocksNonempty := by
@@ -344,17 +344,17 @@ private theorem constAddresses : IxonEnv.ConstAddressIntegrity env := by
     subst lazy
     exact falseProjectionHashNative
   · have hlazy := Option.some.inj
-      (hlookup.symm.trans recursorBlockLookupNative)
+      (hlookup.symm.trans trueProjectionLookupNative)
     subst lazy
-    exact recursorBlockHashNative
+    exact trueProjectionHashNative
   · have hlazy := Option.some.inj
       (hlookup.symm.trans recursorProjectionLookupNative)
     subst lazy
     exact recursorProjectionHashNative
   · have hlazy := Option.some.inj
-      (hlookup.symm.trans trueProjectionLookupNative)
+      (hlookup.symm.trans recursorBlockLookupNative)
     subst lazy
-    exact trueProjectionHashNative
+    exact recursorBlockHashNative
   · have hlazy := Option.some.inj
       (hlookup.symm.trans familyBlockLookupNative)
     subst lazy
@@ -378,17 +378,17 @@ private theorem constMaterialization :
     subst lazy
     exact ⟨falseProjectionConstant, rfl⟩
   · have hlazy := Option.some.inj
-      (hlookup.symm.trans recursorBlockLookupNative)
+      (hlookup.symm.trans trueProjectionLookupNative)
     subst lazy
-    exact ⟨recursorBlockConstant, rfl⟩
+    exact ⟨trueProjectionConstant, rfl⟩
   · have hlazy := Option.some.inj
       (hlookup.symm.trans recursorProjectionLookupNative)
     subst lazy
     exact ⟨recursorProjectionConstant, rfl⟩
   · have hlazy := Option.some.inj
-      (hlookup.symm.trans trueProjectionLookupNative)
+      (hlookup.symm.trans recursorBlockLookupNative)
     subst lazy
-    exact ⟨trueProjectionConstant, rfl⟩
+    exact ⟨recursorBlockConstant, rfl⟩
   · have hlazy := Option.some.inj
       (hlookup.symm.trans familyBlockLookupNative)
     subst lazy
@@ -436,14 +436,14 @@ def blockOfIdempotent : IxonEnv.BlockOfIdempotent env := by
       · simp [blockOfAddr, falseProjectionEntry.getConst,
           familyBlockEntry.getConst, falseProjectionConstant,
           familyBlockConstant]
-      · simp [blockOfAddr, recursorBlockEntry.getConst,
-          recursorBlockConstant]
-      · simp [blockOfAddr, recursorProjectionEntry.getConst,
-          recursorBlockEntry.getConst, recursorProjectionConstant,
-          recursorBlockConstant]
       · simp [blockOfAddr, trueProjectionEntry.getConst,
           familyBlockEntry.getConst, trueProjectionConstant,
           familyBlockConstant]
+      · simp [blockOfAddr, recursorProjectionEntry.getConst,
+          recursorBlockEntry.getConst, recursorProjectionConstant,
+          recursorBlockConstant]
+      · simp [blockOfAddr, recursorBlockEntry.getConst,
+          recursorBlockConstant]
       · simp [blockOfAddr, familyBlockEntry.getConst,
           familyBlockConstant]
       · simp [blockOfAddr, familyProjectionEntry.getConst,
@@ -902,22 +902,22 @@ private theorem decodedGetConst_of_original {addr : Address}
   rw [BooleanEnumerationFixture.sourceKeys] at hkey
   simp at hkey
   rcases hkey with rfl | rfl | rfl | rfl | rfl | rfl
-  · have hc := Option.some.inj
-      (hget.symm.trans originalRecursorBlockLookupNative)
-    subst constant
-    exact recursorBlockEntry.getConst
   · have hc := Option.some.inj
       (hget.symm.trans originalFalseProjectionLookupNative)
     subst constant
     exact falseProjectionEntry.getConst
+  · have hc := Option.some.inj
+      (hget.symm.trans originalTrueProjectionLookupNative)
+    subst constant
+    exact trueProjectionEntry.getConst
   · have hc := Option.some.inj
       (hget.symm.trans originalRecursorProjectionLookupNative)
     subst constant
     exact recursorProjectionEntry.getConst
   · have hc := Option.some.inj
-      (hget.symm.trans originalTrueProjectionLookupNative)
+      (hget.symm.trans originalRecursorBlockLookupNative)
     subst constant
-    exact trueProjectionEntry.getConst
+    exact recursorBlockEntry.getConst
   · have hc := Option.some.inj
       (hget.symm.trans originalFamilyBlockLookupNative)
     subst constant
diff --git a/Tests/AggrSemantics.lean b/Tests/AggrSemantics.lean
index f042f936e..249fcd372 100644
--- a/Tests/AggrSemantics.lean
+++ b/Tests/AggrSemantics.lean
@@ -89,10 +89,10 @@ private def stage2FixtureStorePath (home : System.FilePath) : System.FilePath :=
 
 /-- Pin a real whole-Mathlib root at the persisted-proof boundary. The 3.33 GB
 environment and 52.5 MB manifest are identified in the adjacent provenance
-record rather than checked in. This proof predates the a8aab731 protocol bump:
-the gate re-hashes and decodes the exact wrapper, pins its unconditional root
-claim, and ensures the current backend rejects it at that protocol boundary
-instead of accidentally accepting an incompatible proof. -/
+record rather than checked in. This proof predates both the a8aab731 protocol
+bump and the Ixon v3 claim envelope. The gate re-hashes the exact old wrapper,
+pins its root bytes and unconditional flag, and checks rejection at the format
+boundary. No legacy decoding path is added to the production reader. -/
 private def stage2FixturePinnedAndFenced : IO Bool := do
   try
     unless (← stage2FixturePath.pathExists) do
@@ -108,11 +108,14 @@ private def stage2FixturePinnedAndFenced : IO Bool := do
     let some root := Address.fromString stage2FixtureRootHex | do
       IO.eprintln "invalid pinned Stage 2 fixture root"
       return false
-    let wrapper ← match Ix.Cli.VerifyCmd.decodeAggregateWrapperAt address bytes with
-      | .error e => IO.eprintln s!"Stage 2 fixture wrapper rejected: {e}"; return false
-      | .ok wrapper => pure wrapper
-    if wrapper.claim != .checkEnv root none then
-      IO.eprintln s!"Stage 2 fixture claim drifted: {wrapper.claim}"
+    if Address.blake3 bytes != address || bytes[0]! != 0xF2 ||
+        bytes.extract 1 33 != root.hash || bytes[33]! != 0 then
+      IO.eprintln "Stage 2 fixture bytes or historical root drifted"
+      return false
+    match Ix.Cli.VerifyCmd.decodeAggregateWrapperAt address bytes with
+    | .error "claim: unsupported object format" => pure ()
+    | _ =>
+      IO.eprintln "Stage 2 fixture did not reject at its format boundary"
       return false
     let ixExe : System.FilePath := ".lake" / "build" / "bin" / "ix"
     unless (← ixExe.pathExists) do
@@ -134,8 +137,8 @@ private def stage2FixturePinnedAndFenced : IO Bool := do
       if out.exitCode == 0 then
         IO.eprintln "obsolete Stage 2 fixture unexpectedly verified under the current protocol"
         return false
-      unless out.stderr.contains "InvalidProofShape" ||
-          out.stdout.contains "InvalidProofShape" do
+      unless out.stderr.contains "claim: unsupported object format" ||
+          out.stdout.contains "claim: unsupported object format" do
         IO.eprintln s!"obsolete Stage 2 fixture failed for an unexpected reason \
 ({out.exitCode}): {out.stderr.take 500}"
         return false
diff --git a/Tests/Cli.lean b/Tests/Cli.lean
index 973ce4754..c6eb7e852 100644
--- a/Tests/Cli.lean
+++ b/Tests/Cli.lean
@@ -1,5 +1,7 @@
 module
 
+public import Ix.Ixon
+
 /- Integration tests for the Ix CLI -/
 
 def Tests.Cli.run (buildCmd: String) (buildArgs : Array String) (buildDir : Option System.FilePath) : IO Unit := do
@@ -48,9 +50,64 @@ private def Tests.Cli.testCompileNoBuild : IO Unit := do
   finally
     IO.FS.removeDirAll dir
 
+private def Tests.Cli.testCompileContracts : IO Unit := do
+  let ix ← IO.FS.realPath ".lake/build/bin/ix"
+  let dir ← IO.FS.createTempDir
+  let source := dir / "Contracts.lean"
+  let output := dir / "contracts.ixe"
+  try
+    IO.FS.writeFile source
+      "import Ix.Compile.SourceContract.Elab\n\
+       import Tests.Ix.SourceContract.Imported\n\
+       def cliLocal (~1 x : Nat) : ~ Nat := x\n\
+       def cliEscape (~1 x : Nat) : Nat := x\n"
+    let compile := fun name flags => IO.Process.output {
+      cmd := ix.toString
+      args := #["compile", source.toString, "--no-build", "--consts", name,
+        "--out", output.toString] ++ flags }
+    for flags in [#[], #["--anon"]] do
+      let result ← compile "cliLocal" flags
+      unless result.exitCode == 0 do
+        throw <| IO.userError s!"annotated CLI compile failed: {result.stderr}\n{result.stdout}"
+      let env ← IO.ofExcept (Ixon.runGetExact Ixon.Env.getEnv (← IO.FS.readBinFile output))
+      let preserved := env.consts.toList.any fun (addr, _) =>
+        match env.getConst? addr with
+        | some { info := .defn d, .. } =>
+          match d.typ, d.value with
+          | .all input result _ _, .lam bodyInput _ _ =>
+            input == ⟨.linear, .localShared⟩ && result == .localShared && bodyInput == input
+          | _, _ => false
+        | _ => false
+      unless preserved do
+        throw <| IO.userError "CLI output lost its linear/local contract"
+      IO.FS.removeFile output
+    -- The registry is loaded from an imported .olean in this fresh process.
+    let imported ← compile "Tests.Ix.SourceContract.Imported.opaqueIdentity" #[]
+    unless imported.exitCode == 0 do
+      throw <| IO.userError s!"imported contract CLI compile failed: {imported.stderr}"
+    let env ← IO.ofExcept (Ixon.runGetExact Ixon.Env.getEnv (← IO.FS.readBinFile output))
+    unless env.consts.toList.any (fun (addr, _) =>
+        match env.getConst? addr with
+        | some { info := .defn d, .. } =>
+          match d.typ, d.value with
+          | .all input _ _ _, .lam bodyInput _ _ =>
+            d.kind == .opaq && input.uses == .linear && bodyInput == input
+          | _, _ => false
+        | _ => false) do
+      throw <| IO.userError "CLI output lost its imported opaque contract"
+    IO.FS.removeFile output
+    for flags in [#[], #["--anon"], #["--allow-partial"]] do
+      let result ← compile "cliEscape" flags
+      if result.exitCode == 0 || (← output.pathExists) then
+        throw <| IO.userError "CLI emitted an artifact for an escaping local input"
+    IO.println "v3 CLI: source/import contracts preserved; local escape rejected in every output mode"
+  finally
+    IO.FS.removeDirAll dir
+
 public def Tests.Cli.suite : IO UInt32 := do
   Tests.Cli.run "lake" (#["exe", "ix", "--help"]) none
   Tests.Cli.testCompileNoBuild
+  Tests.Cli.testCompileContracts
   --Tests.Cli.run "ix" (#["store", "ix_test/IxTest.lean"]) none
   --Tests.Cli.run "ix" (#["prove", "ix_test/IxTest.lean", "one"]) none
   return 0
diff --git a/Tests/FFI/Ix.lean b/Tests/FFI/Ix.lean
index 22d895d95..b1da48b33 100644
--- a/Tests/FFI/Ix.lean
+++ b/Tests/FFI/Ix.lean
@@ -151,6 +151,41 @@ def ixNameEq (a b : Ix.Name) : Bool := a.getHash == b.getHash
 def ixLevelEq (a b : Ix.Level) : Bool := a.getHash == b.getHash
 def ixExprEq (a b : Ix.Expr) : Bool := a.getHash == b.getHash
 
+/-! ## String payload preservation -/
+
+/-- Inspect payloads directly: cached Name/Expr hashes survive FFI conversion
+even when a string constructor corrupts the payload. -/
+def stringPayloadTests : TestSeq := Id.run do
+  let mut tests := TestSeq.done
+  for (label, value) in [
+      ("empty", ""),
+      ("leading NUL", "\x00prefix"),
+      ("interior NUL", "left\x00right"),
+      ("trailing NUL", "/profile\x00"),
+      ("multiple NULs", "\x00\x00"),
+      ("Unicode and NULs", "λ\x00雪\x00")] do
+    let name := Ix.Name.mkStr Ix.Name.mkAnon value
+    let expr := Ix.Expr.mkLit (.strVal value)
+    let substring : Ix.Substring := ⟨value, 0, value.utf8ByteSize⟩
+    let atom : Ix.Syntax := .atom .none value
+    let preresolved : Ix.SyntaxPreresolved := .decl name #[value]
+    let data : Ix.DataValue := .ofString value
+    let sameName : Bool := match roundtripIxName name with
+      | .str _ actual _ => actual == value
+      | _ => false
+    let sameLiteral : Bool := match roundtripIxExpr expr with
+      | .lit (.strVal actual) _ => actual == value
+      | _ => false
+    tests := tests ++
+      test s!"Ix.Name string payload: {label}" sameName ++
+      test s!"Ix.Expr string payload: {label}" sameLiteral ++
+      test s!"Ix.Substring string payload: {label}" (roundtripIxSubstring substring == substring) ++
+      test s!"Ix.Syntax string payload: {label}" (roundtripIxSyntax atom == atom) ++
+      test s!"Ix.SyntaxPreresolved string payload: {label}"
+        (roundtripIxSyntaxPreresolved preresolved == preresolved) ++
+      test s!"Ix.DataValue string payload: {label}" (roundtripIxDataValue data == data)
+  return tests
+
 /-! ## Comparison helpers -/
 
 /-- Compare RustCondensedBlocks by checking array sizes.
@@ -256,6 +291,7 @@ def compileErrorTests : TestSeq :=
 /-! ## Test Suite -/
 
 public def suite : List TestSeq := [
+  stringPayloadTests,
   -- Block comparison types
   blockCompareResultTests,
   blockCompareDetailTests,
diff --git a/Tests/FFI/Ixon.lean b/Tests/FFI/Ixon.lean
index b2aaffbb4..b4c21f094 100644
--- a/Tests/FFI/Ixon.lean
+++ b/Tests/FFI/Ixon.lean
@@ -145,7 +145,7 @@ def ixonExprTests : TestSeq :=
   test "Ixon.Expr.app" (roundtripIxonExpr (.app (.var 0) (.var 1)) == .app (.var 0) (.var 1)) ++
   test "Ixon.Expr.lam affine" (roundtripIxonExpr (.lam .affine (.sort 0) (.var 0)) == .lam .affine (.sort 0) (.var 0)) ++
   test "Ixon.Expr.all linear unique" (roundtripIxonExpr (.all .linear .unique (.sort 0) (.var 0)) == .all .linear .unique (.sort 0) (.var 0)) ++
-  test "Ixon.Expr.letE" (roundtripIxonExpr (.letE true (.sort 0) (.var 0) (.var 1)) == .letE true (.sort 0) (.var 0) (.var 1)) ++
+  test "Ixon.Expr.letE" (roundtripIxonExpr (.letE (.lean true) (.sort 0) (.var 0) (.var 1)) == .letE (.lean true) (.sort 0) (.var 0) (.var 1)) ++
   test "Ixon.Expr.prj" (roundtripIxonExpr (.prj 0 1 (.var 0)) == .prj 0 1 (.var 0))
 
 /-! ## Metadata Unit Tests -/
diff --git a/Tests/Fixtures/ixon-v3/addressed.tsv b/Tests/Fixtures/ixon-v3/addressed.tsv
new file mode 100644
index 000000000..29263dc56
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/addressed.tsv
@@ -0,0 +1,5 @@
+# name	address	canonical bytes
+unit	cfec05d1d7f2512f6577c2f61a840523804c36d4043c252ab4ba2508ede75171	c1010000000000010000000000300000000100
+identity	2bfe346531f29ca79736cba6b86eec46c2451fd6f6c8c8ed70580541bc131dca	d00100913d20002000810d2000b0011001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac00
+identity_unique	bf78ce4d73d6a6ddc46f6324a1d8d86ebcca4e1a6e4ceb9c423b06b188f25e57	d0010091012000200081012000b0011001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac00
+profile	e00a234193f2bc4d95f8f3078ade98a0a4edc843b2e87108b462f77eb1a2a704	69786f6e2d76332f7265736f757263652d76312f70726f66696c65000001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac0001e35ab17358fae7a81efb3d94a164fd3f85ab8b0c888aaa071cfe0d60ffbc1cac0081000182a08601
diff --git a/Tests/Fixtures/ixon-v3/claims.tsv b/Tests/Fixtures/ixon-v3/claims.tsv
new file mode 100644
index 000000000..4c3aa7f28
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/claims.tsv
@@ -0,0 +1,8 @@
+# Ixon v3 claims: name, BLAKE3, canonical bytes
+eval	bdb4aba0a94573eb1b00e78bb3a21bed8d412342edc9ff92ee822ab672924000	e3030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d55301633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8
+check	c3db3161d1a2861f4d6d2cd6b19259ca80fde1a678b876cd8c8ede6c5b19dec3	e4030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f00
+check_env	6b805be3f0317c7c63bd7e1015420fbc2af23453f09460ffc0fa7eec894e9421	e5030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f01633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8
+reveal	48ac6a16791489b9217f891ece07fbd550d8ece67d550949442b0a98077436b3	e6030017762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f0200
+contains	6dc0d713f870034fd1da263812086f0f62caf4a6757ceb2b5af0c5243e992791	e7030017762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d553
+catalog	2bb645df227f0b03ee9496cc3635e7a00e031a1698d5fd2c77f2294409c55112	e808030117762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d55301633a6413b154ef0ada30dbc102c8d497e392c1ecd7f2071b4653be5400cad1b8
+resource	c7170cd2fc32f02ebd6a86618f1c54a073ca4469c85fcb3111c1c1196f3769f3	e809030217762fddd969a453925d65717ac3eea21320b66b54342fde15128d6caf21215f10e5cf3d3c8a4f9f3468c8cc58eea84892a22fdadbc1acb22410190044c1d553
diff --git a/Tests/Fixtures/ixon-v3/expressions.txt b/Tests/Fixtures/ixon-v3/expressions.txt
new file mode 100644
index 000000000..e9a764cc3
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/expressions.txt
@@ -0,0 +1,12 @@
+# Independently specified Ixon v3 bytes: relative locality, no lifetime parameters.
+app 7313121110
+lam 8307000700070010
+lam_local_unique 81090010
+lam_affine_local 810e0010
+all 922900170010
+ordinary_let a100006110
+local_unique_let a00a001110
+borrow a20e0041021110
+borrow_nondep a30f001110
+reference 2000
+recursion 32020001
diff --git a/Tests/Fixtures/ixon-v3/handoff/accepted.claim b/Tests/Fixtures/ixon-v3/handoff/accepted.claim
new file mode 100644
index 000000000..6ecbba2f9
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/handoff/accepted.claim
@@ -0,0 +1 @@
+�	��q�:秪����DZ����� �L��y
��id��ç7)w����Ǣ��*��ƫ��
\ No newline at end of file
diff --git a/Tests/Fixtures/ixon-v3/handoff/accepted.ixe b/Tests/Fixtures/ixon-v3/handoff/accepted.ixe
new file mode 100644
index 000000000..07c83f03c
Binary files /dev/null and b/Tests/Fixtures/ixon-v3/handoff/accepted.ixe differ
diff --git a/Tests/Fixtures/ixon-v3/handoff/manifest.json b/Tests/Fixtures/ixon-v3/handoff/manifest.json
new file mode 100644
index 000000000..59e77394b
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/handoff/manifest.json
@@ -0,0 +1,16 @@
+{"validator": "ixon-v3/resource-v1",
+ "subject": "f0e971f93ae7a7aa0fbf87df16a2445afdbb8d89dc0c20934cb9ae7901958269",
+ "schema": "ixon-v3-handoff-1",
+ "profile": "64abccc3a713372977c3f3857febbdccc7a20fb08c2a86f0bbbec6ab0e880794",
+ "objectFormat": "ixon-v3",
+ "ixvmResourceProof": false,
+ "files":
+ {"rejected-local-escape.ixe":
+  "b9a28e222a6deaf7fae2ca386e5f2dda91b464cf2d7e9e713b2c42bdfc6a3019",
+  "profile.bin":
+  "64abccc3a713372977c3f3857febbdccc7a20fb08c2a86f0bbbec6ab0e880794",
+  "accepted.ixe":
+  "b6d12995849c9dfdf2956653e41256a3567b1b9359148a34e1044ad4a7efff89",
+  "accepted.claim":
+  "0c770089a4c33228e1e46d8c040b8698c32fa785b5bde552664f677b45409a48"},
+ "claim": "0c770089a4c33228e1e46d8c040b8698c32fa785b5bde552664f677b45409a48"}
diff --git a/Tests/Fixtures/ixon-v3/handoff/profile.bin b/Tests/Fixtures/ixon-v3/handoff/profile.bin
new file mode 100644
index 000000000..213d5e6e3
Binary files /dev/null and b/Tests/Fixtures/ixon-v3/handoff/profile.bin differ
diff --git a/Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe b/Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe
new file mode 100644
index 000000000..e073192ef
Binary files /dev/null and b/Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe differ
diff --git a/Tests/Fixtures/ixon-v3/primitives.tsv b/Tests/Fixtures/ixon-v3/primitives.tsv
new file mode 100644
index 000000000..4337a99f4
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/primitives.tsv
@@ -0,0 +1,94 @@
+# Ixon v3 canonical primitive addresses
+Nat	35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc
+Nat.zero	eeb2e6268ff6d0e6b2e9764d9940b81bb64b9f8f4b1358d294ff9817e6941a46
+Nat.succ	42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6
+Nat.add	724db797e1817545a08371432fd1fa6428a37dcf9c1671df7e464849db0a81ac
+Nat.pred	76afa254a8bbf2ac4327d7b94be0c63bd708836b5f7384ce990388adb0a1d3cf
+Nat.sub	9de2d2c60e7d421a2fdfb8706e91e0e6d8576c3bd46ec00405c65875cb9b5a26
+Nat.mul	566a3c2249bc2076543d9bc561a841f6fd35ffb5bdbbc5c991a9c64feccbd5d4
+Nat.pow	5ba43ac3e5d29fe5ce81f18a18178a2705c37ee674b9b6ee50e9466a86593b15
+Nat.gcd	76007dcf8b285cdbd6f779012290fe2e6afd221ce8821082a7e2ef81e8d815cf
+Nat.mod	e6ffe78713d4b974a82d0187538f1a0cf5c4b260f0fd99264fab263b1af847f9
+Nat.div	c075ed976f1702f364fb0bb34aa8bbc166adace573f2ce914b43dc4f4aab6219
+Nat.bitwise	aaf7df6a1f024f580fde236cba16235f071d1b796cc279faf43178d22b5ae36d
+Nat.beq	ffd3f02a19fda649aa5608ed818db382e160231b76d5b09176d7dd1a8d5b1ec5
+Nat.ble	68a3643ec69816aec107302ddbfa054cebcd3ec173cd5f7e6d883638631afe65
+Nat.land	c61fad46a102dbff5922312d4fbe6e704ec3c62c6c6f64b3d481b78c77cf315d
+Nat.lor	cb7dccc020a530fed7c622b100ee52c1078b5018159ba4682f817e3776789ee8
+Nat.xor	d8a6b05a1a4e5cadc69c53792e8e130314745e76e32bb30a9ce0272fa079e8a6
+Nat.shiftLeft	5c15f98e2bd9c257bcdfac62b0043a2e3e2bbdff8b210f104b5c3739e862ac0c
+Nat.shiftRight	3f92725324b09fa75c6fcd16da863671428ff33b7db667eb760e1cd503a2bcad
+Bool	e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4
+Bool.true	a29a636176cf1135d077eb074798f9007c78e7801383e9cff363bae5edf05762
+Bool.false	dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e
+String	9d6ae43429ec02a9338bbcd0db0ac193d75ebd46f884bfcbd2c42bf7faea150d
+String.mk	272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2
+Char	4c59bc4eac82d31ebed59bb206909dbded65b92fd56de2518fcdadb0a42c11a0
+Char.mk	82e09601422cae23b0b6df9922abb9f0b014e20047a00a7ab96871dd7da3e5ac
+Char.ofNat	caf51b039d71cfce7063e106064f9435f5337bbc42567c8c78b5f66c7f087920
+String.ofList	272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2
+List	4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01
+List.nil	3994bc51e3686f30a1d483d69d0a835a7b484d892393c084f87a5849de54f302
+List.cons	b3a7d80249fd823100ee03626232d1412a0e8335275d5df53b92943887b650f7
+Eq	c37d6290e00fb865fb5db7bce18fd69e6d1674ad573724b85466ea9f7578a207
+Eq.refl	d494dc601386ba8e8f0b711fe62a2d60ab60c6488c8cf6ce97796ebc3ad5fefb
+Quot	45040b3126855169dad919a970a9c72cee5875658aedb3bd1f89fcdf8c88edfa
+Quot.mk	811600dfa59f3612cb03c0f0475af152399defff9226c6e19fd648041a6899a9
+Quot.lift	86b365e75bb4230f04c6e4f3a7ca6988adf574616d79a3d7477ad65cac102110
+Quot.ind	1745491c0d651de0bea589d5fffbc9bc4d7fbe897c1d805b1f7f59ca9696a6ef
+Lean.reduceBool	bacc4c814a4572ddfd969a1857adfe18239eb6bd8b1627ee79744a6a9b23b030
+Lean.reduceNat	b6327d9a1bbb461a447f0c971e622dd9a35132bd7de75bf69e20794d7a0e8595
+eagerReduce	173299c76efa82e689210a09e49ad09c14ee1108f2da8d355ef9333b1583a1d5
+System.Platform.numBits	6f620654d341990a301387b80ef75b1e0b6130ddf19164025b6dc37bf3c3dc18
+System.Platform.getNumBits	00c266834f9039931b4be2fac5584cd176a0ae7ee4cb4064ddb5e04dd12b6cbb
+Subtype.val	ea65f517457fae9b705299da08b0d3c8cf9a476f16470cca5cae5ea7bd238230
+String.toByteArray	79862acfbc2e37b7b6122143f0a6a51114c34fa483ff14146483de18835d4209
+ByteArray.empty	bf58e6cb3aa0f746850629041635cd30c0ad66262b6617660f2290241f08b08b
+Nat.decLe	f0f15ed079822f06e82e36664bf61e797e5b1e7b0b4155152762c513274bfee1
+Nat.decEq	8a5d5eee414a2fa5956b74e8323a20508d774ed1b5603f55e774ad896bd3e6e7
+Nat.decLt	7c4977196e95be2a759fc9c6d1533db8da49592f06419b155d888333c8dd8931
+Decidable.rec	16cfddda9c274660f391b10eefe066275afffae1ccd49c6daf43afb8a80aea85
+Decidable.isTrue	363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da
+Decidable.isFalse	8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b
+Nat.le_of_ble_eq_true	ad25bfd207bae832c73d5ce614bead22ef9862e110f8d17a5064ffb7603eee3d
+Nat.not_le_of_not_ble_eq_true	e3658f50dc5123efff213588dee3d4c6063f5edb18950850ac0490c937819009
+Nat.eq_of_beq_eq_true	9c91e79de732226ba2e73cbdd330851baec40668eb40c6f32aa2f8dac5a04b51
+Nat.ne_of_beq_eq_false	a07db532747e65ee77a7ba015069bdbaf1f709ce0d60b83c94f40d0e5e57595a
+Fin	3d79797bc572d8f33eb7cff5aa13f8dc73bcf21026bf05d03888c9aa0369dcef
+Bool.noConfusion	de7b523cc4470e15328a01d935988861dadf9bd012240400464dea8c79a9dfe2
+Int	c60c95e3cdbf4ed010d999b3277f4e1fd3695e8c30260876102905d7b36241a2
+Int.ofNat	0a99f49cc73ab9f42783092e7120613225670bab89b9d63533d1adefc876182f
+Int.negSucc	f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc
+Int.add	9db0177e4e8b6a0e7323069509c2457de9598a7e38e72ffe19ad34617256e10d
+Int.sub	85621387ef3027028d835287f3cc1461ef041def1fd91e28e87f669cc04a5eea
+Int.mul	b05459623d23299d3a849eb7fb75badbc1547a1cd9ee560c15067fbd985c6cea
+Int.neg	6701d765ff10bfa3a6c347df15194e0db862ee25b54f25a59f7cf21951a3997e
+Int.emod	e29cfa7921bb57f4782b021c977596a4fae04e94f7b07955fe2814fc48de90e7
+Int.ediv	9c952d45a3bd43161529fcfb5e276beab0cf4fd64a01ba9bc2c7cda376cb8f54
+Int.bmod	0b1564dea6ffcd204ebcd1aa69d29ee6f3acccd87bd146ff674556ac9cc8ccb3
+Int.bdiv	6d35dc43660f6c509a13f2824c027ed99ab070a08f058ff0a5f46a759250797d
+Int.natAbs	261ae54edb66e900784a64350bc01e8b3fe1332a47caeab58e0361dffc7ea008
+Int.pow	87266415982bbdec50c61dec5b73cc0ccd5c997445997a9724a1cc5c2e39d3a4
+Int.decEq	fc8c44cc970cfc183ccd10a2d1cdeb2c849307760e91f5cd29a2b02f706d83da
+Int.decLe	fcdf1860ad4cd672239392e60e7b49e024af0475739c3a40195a914eaec42c04
+Int.decLt	1d54806ab1ebc791e1db96e88d0407cef3523927d60ba669689b92a8eeb36445
+PUnit	2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b
+PProd	90ca5bcf995d68d7dfcb3c7cfe466986dc4beaa402b262ca395b3e53c36f6cad
+PProd.mk	ce30fc0f4135e679cf3b16d0d667bd9df4e7a69dbb8177a29e5c75b48c4cec10
+Nat.rec	d1053449c217e5cc6fc29b2cb59cfd5ead385d392d00ada2221d4000dda7def3
+Nat.casesOn	c575abb02efd158091356aa793c809c0570f8a24a8a777f206a95b9ce0b88855
+BitVec	7f0f5feda1828072123f242a46a40549e85934f7395e4f93f65dda4e4809f325
+BitVec.toNat	c110d614b441c6cca69ecd7c1c2c76f3bc21fd40c4001e6a1a7d1cf481e23cdd
+BitVec.ofNat	29b9f24086b1b1f88211358866139fdb7dcdfc97b5f6c77fc495bf8c77639982
+BitVec.ult	9301d850bde246940b7b3e81e786f7f12bae8e5cea6b3f4040060b3a7f59557c
+Decidable.decide	20e8906280b4dcd74a7a78e06d580e6f00eebba9fc40789262e95cacb6f0d699
+LT.lt	4802b183f4d6dcccacba57721824a7bb67daeb2725da17239271c135952caa61
+OfNat.ofNat	a99dedbb1676866aed829c3d4bba86a37e98ec62a35834389c32937e4e2b1a4a
+Unit	9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb
+PUnit._sizeOf_1	e85bf516c76cadd8ce1fdab3cc94ed685e47be3c7a8b52f53fe2b3502e6f70c7
+SizeOf.sizeOf	402b71bcccf0be0315f1bda6bdbb20e559e31704617d3eaccb05d5c5fe03b53d
+String.back	32104b03348d11acb2437fda24966dc58cc8c8bcca96582614e644d319a42c62
+String.Legacy.back	37ef5fee765dc2e5c7425c180cd42007db7d29ae0d5c091789f462f2805b0e09
+String.utf8ByteSize	52b0226ea14c94b1f9334c9957f5589399a86bcdae111f2847c9b0c2fb0a2261
+String.append	132f1175cc3cac5a3e3d74e8797f9ba67f2e467b8004a3f28bb5dfd16a3647b1
+String.decEq	19134fdc188e8377d0173857e15d3b5065ed76da981397107e5c404db3f3b718
diff --git a/Tests/Fixtures/ixon-v3/resource.tsv b/Tests/Fixtures/ixon-v3/resource.tsv
new file mode 100755
index 000000000..f38465e09
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/resource.tsv
@@ -0,0 +1,67 @@
+# name	expected	type (ixon-v3 hex)	body (ixon-v3 hex)
+ordinary identity	ok	911720002000	8107200010
+linear identity	ok	911520002000	8105200010
+linear unique transfer	ok	910120002000	8101200010
+unused erased	ok	911420002000	8104200060
+erased argument has zero demand	ok	911420002000	8104200071200410
+unused affine	ok	911620002000	8106200060
+missing linear consumption	usage	911520002000	8105200060
+runtime erased variable	usage	911420002000	8104200010
+many invocation scales demand	usage	911620002000	8106200071200510
+many permits repeated demand	ok	911720002000	8107200071200510
+linear ordinary let	ok	911520002000	81052000a00520001010
+erased let initializer	ok	911520002000	81052000a00420001011
+duplicate affine through let	usage	911620002000	81062000a00620001011
+shared cannot become unique	ownership	910520002000	8105200010
+unique cannot transfer twice despite many	moved	910320002000	81032000a001200010a00120001110
+permanent sharing relinquishes unique	ownership	910320002000	81032000a00620001011
+local input local output	ok	913d20002000	810d200010
+local unique input local unique output	ok	912920002000	8109200010
+local input cannot escape	unrestricted	911d20002000	810d200010
+local helper result can be forwarded	ok	913d20002000	810d200071200210
+inner local let cannot escape as local	escape	913520002000	81052000a00d20001010
+borrow ends before owner transfer	ok	910120002000	81012000a0062000a20f2000107120011011
+unique access during loan	loan	910120002000	81012000a20f20001011
+loan view cannot escape	escape	913320002000	81032000a20f20001010
+loan end does not restore permanently shared owner	ownership	910320002000	81032000a0062000a20f2000101111
+nested shared reborrow	ok	910120002000	81012000a0062000a20f200010a20f2000107120011011
+borrow requires owner place	place	911320002000	81032000a20f20007120031060
+borrow cannot manufacture unique view	borrow	911320002000	81032000a20b20001060
+moved owner cannot be borrowed	moved	910320002000	81032000a001200010a20f20001111
+projected loan suspends whole owner	loan	910120072007	81012007a20f200040071011
+projected loan ends before owner transfer	ok	910120072007	81012007a0062000a20f20004007107120011011
+unregistered projection has no optimistic rule	unsupported	911320002000	81032000400010
+shared closure cannot hide affine capture	capture	921620001720002000	8206200007200011
+unique closure retains finite capture	ok	920520001720002000	8205200007200011
+local closure may retain local input	ok	923f20003720002000	820f200007200011
+closure cannot hide local escape	unrestricted	921f20003720002000	820f200007200011
+aggregate cannot hide local escape	unrestricted	911d20002007	810d200071200810
+aggregate retains caller locality	ok	913d20002007	810d200071200810
+linear use in both alternatives	ok	911520002000	81052000732006601010
+linear missing in one alternative	usage	911520002000	81052000732006601060
+affine use in one alternative	ok	911620002000	81062000732006601060
+unique move in each alternative	ok	910120002000	8101200073200a601010
+alternative move prevents later use	moved	910320002000	81032000a002200073200a60106011
+partial selection is not an ordinary function	unsupported	911720002000	8107200071200610
+sharing checked in live binder context	ok	911520002000	81052000b0
+sharing cannot cache away erased restriction	usage	911420002000	81042000b0
+lambda and interface input must agree	binder	911520002000	8107200010
+fresh inner linear binder under many demand	ok	911720002000	81072000712005a00520001010
+discarding borrow before narrowing fresh result	ok	913320002000	81032000a20f20001071200110
+type formation has zero runtime demand	ok	91140000	81040010
+type use cannot discharge linear runtime obligation	usage	91150000	81050010
+selection cannot bypass its rule through a callback	unsupported	941720001520001620001620002000	810720002006
+shared aggregate cannot expose reusable unique closure	capture	921520071720002000	81052007410710
+unique aggregate transfers unique closure field	ok	920120071720002000	81012007410710
+shared field retains its reusable function contract	ok	921520071720002000	81052007420710
+projected borrow cannot launder unique closure	capture	911720072000	81072007a20f91172000200041071060
+capturing owner transfers it even when closure only borrows	ok	920120001720002000	82012000072000a20f20001171200110
+branch analysis follows a shared application head	ok	911520002000	8105200073b1601010
+erased owner cannot be restored through a borrow	unsupported	911020002000	81002000a20f20001071200110
+erased view cannot be restored through a reborrow	unsupported	911320002000	81032000a20c200010a20f20001071200110
+erased higher order argument still checks its contracts	type	91149115200020002000	81049115200020007181049117200020006010
+erased higher order argument with matching interface	ok	91149117200020002000	81049117200020007181049117200020006010
+reborrowing closure captures the view without moving its root	ok	910120002000	81012000a0062000a20f200010a00d91172000200081072000a20f2000117120011071106011
+higher order local callback and argument	ok	923f911d200020001d20002000	820f911d200020000d2000711110
+recursive contract retains resource across alternatives	ok	921720003d20002000	820720000d2000732009601072200b1110
+higher order contract mismatch	type	9217911d20002000179117200020002000	8207911d20002000072000a0059117200020001160
diff --git a/Tests/Fixtures/ixon-v3/text.tsv b/Tests/Fixtures/ixon-v3/text.tsv
new file mode 100644
index 000000000..2dc6ac976
--- /dev/null
+++ b/Tests/Fixtures/ixon-v3/text.tsv
@@ -0,0 +1,148 @@
+lam	0	0	fun (!0 x : A) => x
+lam	1	0	fun (!1 x : A) => x
+lam	2	0	fun (!& x : A) => x
+lam	3	0	fun (! x : A) => x
+lam	4	0	fun (0 x : A) => x
+lam	5	0	fun (1 x : A) => x
+lam	6	0	fun (& x : A) => x
+lam	7	0	fun (x : A) => x
+lam	8	0	fun (~!0 x : A) => x
+lam	9	0	fun (~!1 x : A) => x
+lam	10	0	fun (~!& x : A) => x
+lam	11	0	fun (~! x : A) => x
+lam	12	0	fun (~0 x : A) => x
+lam	13	0	fun (~1 x : A) => x
+lam	14	0	fun (~& x : A) => x
+lam	15	0	fun (~ x : A) => x
+all	0	0	(!0 x : A) → ! B
+all	0	1	(!0 x : A) → B
+all	0	2	(!0 x : A) → ~! B
+all	0	3	(!0 x : A) → ~ B
+all	1	0	(!1 x : A) → ! B
+all	1	1	(!1 x : A) → B
+all	1	2	(!1 x : A) → ~! B
+all	1	3	(!1 x : A) → ~ B
+all	2	0	(!& x : A) → ! B
+all	2	1	(!& x : A) → B
+all	2	2	(!& x : A) → ~! B
+all	2	3	(!& x : A) → ~ B
+all	3	0	(! x : A) → ! B
+all	3	1	(! x : A) → B
+all	3	2	(! x : A) → ~! B
+all	3	3	(! x : A) → ~ B
+all	4	0	(0 x : A) → ! B
+all	4	1	(0 x : A) → B
+all	4	2	(0 x : A) → ~! B
+all	4	3	(0 x : A) → ~ B
+all	5	0	(1 x : A) → ! B
+all	5	1	(1 x : A) → B
+all	5	2	(1 x : A) → ~! B
+all	5	3	(1 x : A) → ~ B
+all	6	0	(& x : A) → ! B
+all	6	1	(& x : A) → B
+all	6	2	(& x : A) → ~! B
+all	6	3	(& x : A) → ~ B
+all	7	0	(x : A) → ! B
+all	7	1	(x : A) → B
+all	7	2	(x : A) → ~! B
+all	7	3	(x : A) → ~ B
+all	8	0	(~!0 x : A) → ! B
+all	8	1	(~!0 x : A) → B
+all	8	2	(~!0 x : A) → ~! B
+all	8	3	(~!0 x : A) → ~ B
+all	9	0	(~!1 x : A) → ! B
+all	9	1	(~!1 x : A) → B
+all	9	2	(~!1 x : A) → ~! B
+all	9	3	(~!1 x : A) → ~ B
+all	10	0	(~!& x : A) → ! B
+all	10	1	(~!& x : A) → B
+all	10	2	(~!& x : A) → ~! B
+all	10	3	(~!& x : A) → ~ B
+all	11	0	(~! x : A) → ! B
+all	11	1	(~! x : A) → B
+all	11	2	(~! x : A) → ~! B
+all	11	3	(~! x : A) → ~ B
+all	12	0	(~0 x : A) → ! B
+all	12	1	(~0 x : A) → B
+all	12	2	(~0 x : A) → ~! B
+all	12	3	(~0 x : A) → ~ B
+all	13	0	(~1 x : A) → ! B
+all	13	1	(~1 x : A) → B
+all	13	2	(~1 x : A) → ~! B
+all	13	3	(~1 x : A) → ~ B
+all	14	0	(~& x : A) → ! B
+all	14	1	(~& x : A) → B
+all	14	2	(~& x : A) → ~! B
+all	14	3	(~& x : A) → ~ B
+all	15	0	(~ x : A) → ! B
+all	15	1	(~ x : A) → B
+all	15	2	(~ x : A) → ~! B
+all	15	3	(~ x : A) → ~ B
+arrow	7	0	A → ! B
+arrow	7	1	A → B
+arrow	7	2	A → ~! B
+arrow	7	3	A → ~ B
+let	0	0	let (!0 x : A) := y; x
+let	1	0	let (!1 x : A) := y; x
+let	2	0	let (!& x : A) := y; x
+let	3	0	let (! x : A) := y; x
+let	4	0	let (0 x : A) := y; x
+let	5	0	let (1 x : A) := y; x
+let	6	0	let (& x : A) := y; x
+let	7	0	let x : A := y; x
+let	8	0	let (~!0 x : A) := y; x
+let	9	0	let (~!1 x : A) := y; x
+let	10	0	let (~!& x : A) := y; x
+let	11	0	let (~! x : A) := y; x
+let	12	0	let (~0 x : A) := y; x
+let	13	0	let (~1 x : A) := y; x
+let	14	0	let (~& x : A) := y; x
+let	15	0	let (~ x : A) := y; x
+let	0	1	have (!0 x : A) := y; x
+let	1	1	have (!1 x : A) := y; x
+let	2	1	have (!& x : A) := y; x
+let	3	1	have (! x : A) := y; x
+let	4	1	have (0 x : A) := y; x
+let	5	1	have (1 x : A) := y; x
+let	6	1	have (& x : A) := y; x
+let	7	1	have x : A := y; x
+let	8	1	have (~!0 x : A) := y; x
+let	9	1	have (~!1 x : A) := y; x
+let	10	1	have (~!& x : A) := y; x
+let	11	1	have (~! x : A) := y; x
+let	12	1	have (~0 x : A) := y; x
+let	13	1	have (~1 x : A) := y; x
+let	14	1	have (~& x : A) := y; x
+let	15	1	have (~ x : A) := y; x
+let	0	2	let borrow (!0 x : A) := y; x
+let	1	2	let borrow (!1 x : A) := y; x
+let	2	2	let borrow (!& x : A) := y; x
+let	3	2	let borrow (! x : A) := y; x
+let	4	2	let borrow (0 x : A) := y; x
+let	5	2	let borrow (1 x : A) := y; x
+let	6	2	let borrow (& x : A) := y; x
+let	7	2	let borrow (x : A) := y; x
+let	8	2	let borrow (~!0 x : A) := y; x
+let	9	2	let borrow (~!1 x : A) := y; x
+let	10	2	let borrow (~!& x : A) := y; x
+let	11	2	let borrow (~! x : A) := y; x
+let	12	2	let borrow (~0 x : A) := y; x
+let	13	2	let borrow (~1 x : A) := y; x
+let	14	2	let borrow (~& x : A) := y; x
+let	15	2	let borrow (~ x : A) := y; x
+let	0	3	have borrow (!0 x : A) := y; x
+let	1	3	have borrow (!1 x : A) := y; x
+let	2	3	have borrow (!& x : A) := y; x
+let	3	3	have borrow (! x : A) := y; x
+let	4	3	have borrow (0 x : A) := y; x
+let	5	3	have borrow (1 x : A) := y; x
+let	6	3	have borrow (& x : A) := y; x
+let	7	3	have borrow (x : A) := y; x
+let	8	3	have borrow (~!0 x : A) := y; x
+let	9	3	have borrow (~!1 x : A) := y; x
+let	10	3	have borrow (~!& x : A) := y; x
+let	11	3	have borrow (~! x : A) := y; x
+let	12	3	have borrow (~0 x : A) := y; x
+let	13	3	have borrow (~1 x : A) := y; x
+let	14	3	have borrow (~& x : A) := y; x
+let	15	3	have borrow (~ x : A) := y; x
diff --git a/Tests/Gen/Claim.lean b/Tests/Gen/Claim.lean
index 059ec5864..5af02dd09 100644
--- a/Tests/Gen/Claim.lean
+++ b/Tests/Gen/Claim.lean
@@ -94,6 +94,7 @@ def genClaim : Gen Claim :=
     (10, Claim.reveal   <$> genAddress <*> genRevealConstantInfo),
     (10, Claim.contains <$> genAddress <*> genAddress),
     (10, Claim.catalog  <$> genAddress <*> genAddress <*> genOptAddress),
+    (10, Claim.resource <$> genAddress <*> genAddress),
   ]
 
 /-! ## Shrinkable instances -/
@@ -131,6 +132,7 @@ instance : Shrinkable Claim where
       (.reveal comm <$> Shrinkable.shrink info) ++ [.check comm none]
     | .contains t _ => [.checkEnv t none]
     | .catalog m _ none => [.checkEnv m none]
+    | .resource _ _ => []
     | .catalog m c (some _) => [.catalog m c none]
 
 /-! ## SampleableExt instances -/
@@ -144,3 +146,4 @@ instance : SampleableExt Claim := SampleableExt.mkSelfContained genClaim
 end Tests.Gen.Claim
 
 end
+
diff --git a/Tests/Gen/Ixon.lean b/Tests/Gen/Ixon.lean
index cb9da56e3..45a85ae62 100644
--- a/Tests/Gen/Ixon.lean
+++ b/Tests/Gen/Ixon.lean
@@ -49,6 +49,18 @@ def genUses : Gen Uses :=
 def genOwned : Gen Owned :=
   elements #[.unique, .shared]
 
+def genLocality : Gen Locality :=
+  elements #[.unrestricted, .local]
+
+def genValueContract : Gen ValueContract :=
+  ValueContract.mk <$> genOwned <*> genLocality
+
+def genBinderContract : Gen BinderContract :=
+  BinderContract.mk <$> genUses <*> genValueContract
+
+def genLetContract : Gen LetContract :=
+  LetContract.mk <$> genBool <*> elements #[.value, .borrowShared] <*> genBinderContract
+
 def genArray (g: Gen α) : Gen (Array α) :=
   Array.mk <$> genList g
 
@@ -95,9 +107,9 @@ partial def genExpr : Gen Expr :=
     (15, .recur <$> genUInt64Small <*> genArray genUInt64Small),
     (5, .prj <$> genUInt64Small <*> genUInt64Small <*> genExpr),
     (5, .app <$> genExpr <*> genExpr),
-    (5, .lam <$> genUses <*> genExpr <*> genExpr),
-    (5, .all <$> genUses <*> genOwned <*> genExpr <*> genExpr),
-    (2, .letE <$> genBool <*> genExpr <*> genExpr <*> genExpr),
+    (5, .lam <$> genBinderContract <*> genExpr <*> genExpr),
+    (5, .all <$> genBinderContract <*> genValueContract <*> genExpr <*> genExpr),
+    (2, .letE <$> genLetContract <*> genExpr <*> genExpr <*> genExpr),
   ]
 
 def genDefinition : Gen Definition :=
@@ -752,3 +764,4 @@ instance : SampleableExt RawEnv := SampleableExt.mkSelfContained genRawEnv
 end Tests.Gen.Ixon
 
 end
+
diff --git a/Tests/Gen/IxonSyntax.lean b/Tests/Gen/IxonSyntax.lean
index ef0b71c19..676b186e0 100644
--- a/Tests/Gen/IxonSyntax.lean
+++ b/Tests/Gen/IxonSyntax.lean
@@ -135,6 +135,21 @@ def genLitString : Gen String :=
       pure s)
   ]
 
+def genValueContract : Gen Ixon.ValueContract := do
+  return {
+    owned := if (← choose Nat 0 1) == 0 then .unique else .shared
+    locality := if (← choose Nat 0 1) == 0 then .unrestricted else .local }
+
+def genBinderContract : Gen Ixon.BinderContract := do
+  let uses ← elements #[Ixon.Uses.erased, .linear, .affine, .many]
+  return { uses, value := ← genValueContract }
+
+def genLetContract : Gen Ixon.LetContract := do
+  return {
+    nonDep := (← choose Nat 0 1) == 0
+    kind := if (← choose Nat 0 1) == 0 then .value else .borrowShared
+    binder := ← genBinderContract }
+
 mutual
 
 partial def genBinder (depth : Nat) : Gen BinderGroup := do
@@ -149,7 +164,7 @@ partial def genBinder (depth : Nat) : Gen BinderGroup := do
       for _ in [0:n] do
         ns := ns.push (← genBinderName)
       pure ns
-  return .mk info names (← genTerm depth) {}
+  return .mk (← genBinderContract) info names (← genTerm depth) {}
 
 partial def genTerm (depth : Nat) : Gen Term := do
   if depth == 0 then
@@ -180,10 +195,10 @@ partial def genTerm (depth : Nat) : Gen Term := do
         let mut bs := #[]
         for _ in [0:n] do
           bs := bs.push (← genBinder d)
-        return .pi bs (← genTerm d) {}),
-      (1, do return .arrow (← genTerm d) (← genTerm d) {}),
+        return .pi bs (← genValueContract) (← genTerm d) {}),
+      (1, do return .arrow (← genValueContract) (← genTerm d) (← genTerm d) {}),
       (1, do
-        return .letE ((← choose Nat 0 1) == 0) (← genBinderName)
+        return .letE (← genLetContract) (← genBinderName)
           (← genTerm d) (← genTerm d) (← genTerm d) {}),
       (1, do return .proj (← genCref) (← choose Nat 0 7) (← genTerm d) {}),
       (1, .ref <$> genCref)
@@ -306,9 +321,9 @@ def shrinkTerm (t : Term) : List Term := Id.run do
     if args.size > 1 then
       for i in [0:args.size] do
         out := out ++ [.app head (args.eraseIdxIfInBounds i) {}]
-  | .lam bs body _ | .pi bs body _ =>
+  | .lam bs body _ | .pi bs _ body _ =>
     out := out ++ [body] ++ (bs.toList.map (·.ty))
-  | .arrow d c _ => out := out ++ [d, c]
+  | .arrow _ d c _ => out := out ++ [d, c]
   | .letE _ _ ty val body _ => out := out ++ [ty, val, body]
   | .proj _ _ v _ => out := out ++ [v]
   | .ref r =>
diff --git a/Tests/Ix/Catalog.lean b/Tests/Ix/Catalog.lean
index 5443fee08..575f0a857 100644
--- a/Tests/Ix/Catalog.lean
+++ b/Tests/Ix/Catalog.lean
@@ -232,8 +232,11 @@ def unitTests : TestSeq :=
       (roundtrips chunkedCat)
   ++ test "bad magic rejected" (deFails (setByte 0 0xFF) "magic")
   ++ test "unknown flags rejected" (deFails (setByte 12 0xFF) "flags")
+  ++ test "legacy manifest rejected" (deFails (setByte 8 1) "version")
+  ++ test "legacy object format rejected" (deFails (setByte 16 2) "format")
+  ++ test "resource validator cannot label catalog" (deFails (setByte 17 2) "validator")
   ++ test "members_root drift rejected"
-      (deFails (setByte (8 + 4 + 4) 0xFF) "members_root")
+      (deFails (setByte (8 + 4 + 4 + 2) 0xFF) "members_root")
   ++ test "truncation rejected" truncationRejected
   ++ test "path-traversal label rejected"
       (Ix.Catalog.validateLabel "../evil" matches .error _)
diff --git a/Tests/Ix/Claim.lean b/Tests/Ix/Claim.lean
index 38d28030b..8ac1cf6db 100644
--- a/Tests/Ix/Claim.lean
+++ b/Tests/Ix/Claim.lean
@@ -84,26 +84,26 @@ def claimEncodingTests : TestSeq :=
     (.reveal addr1 (.defn none (some .safe) none none none))
   let revealAllFields := Claim.ser (.reveal addr1
     (.defn (some .defn) (some .safe) (some 3) (some addr2) (some addr3)))
-  -- Eval claim: 0xE3 + 64 + 1 (opt) = 66 bytes; with asm = 98
+  -- Two scope bytes follow each claim tag. Eval = 68 bytes; with asm = 100
   test "Eval tag byte is 0xE3" (evalBytes.data[0]! == 0xE3)
-  ++ test "Eval no-asm size is 66" (evalBytes.size == 66)
-  ++ test "Eval with-asm size is 98" (evalWithAsm.size == 98)
-  -- Check claim: 0xE4 + 32 + 1 = 34 bytes; with asm = 66
+  ++ test "Eval no-asm size is 68" (evalBytes.size == 68)
+  ++ test "Eval with-asm size is 100" (evalWithAsm.size == 100)
+  -- Check: tag + scope + 32 + option = 36 bytes; with asm = 68
   ++ test "Check tag byte is 0xE4" (checkBytes.data[0]! == 0xE4)
-  ++ test "Check no-asm size is 34" (checkBytes.size == 34)
-  ++ test "Check with-asm size is 66" (checkWithAsm.size == 66)
-  -- CheckEnv claim: 0xE5 + 32 + 1 = 34 bytes
+  ++ test "Check no-asm size is 36" (checkBytes.size == 36)
+  ++ test "Check with-asm size is 68" (checkWithAsm.size == 68)
+  -- CheckEnv: tag + scope + 32 + option = 36 bytes
   ++ test "CheckEnv tag byte is 0xE5" (checkEnvBytes.data[0]! == 0xE5)
-  ++ test "CheckEnv no-asm size is 34" (checkEnvBytes.size == 34)
+  ++ test "CheckEnv no-asm size is 36" (checkEnvBytes.size == 36)
   -- Reveal claim: 0xE6
   ++ test "Reveal tag byte is 0xE6" (revealSafetyOnly.data[0]! == 0xE6)
-  -- Reveal safety-only defn: 1 (tag) + 32 (comm) + 1 (variant) + 1 (mask) + 1 (safety) = 36
-  ++ test "Reveal safety-only defn size is 36" (revealSafetyOnly.size == 36)
+  -- Reveal: tag + scope + commitment + variant + mask + safety = 38
+  ++ test "Reveal safety-only defn size is 38" (revealSafetyOnly.size == 38)
   ++ test "Reveal all-fields defn is larger"
        (revealAllFields.size > revealSafetyOnly.size)
-  -- Contains claim: 0xE7 + 64 = 65
+  -- Contains: tag + scope + two addresses = 67
   ++ test "Contains tag byte is 0xE7" (containsBytes.data[0]! == 0xE7)
-  ++ test "Contains size is 65" (containsBytes.size == 65)
+  ++ test "Contains size is 67" (containsBytes.size == 67)
 
 /-! ## Catalog claim: wire pin + Rust digest parity
 
@@ -121,7 +121,7 @@ private def catAsm : Address := Address.blake3 "assumptions".toUTF8
 
 /-- Must equal the Rust pin in `proof.rs::catalog_claim_wire_bytes_pinned`. -/
 private def catalogDigestPin : String :=
-  "608af1f5477517d14427da664ae7a62d46cd9236b2183481c7801910683579bf"
+  "1ae7fec8efde892b6b540888df70d53977a264bbc84be300d4335ce04c916072"
 
 def catalogClaimTests : TestSeq :=
   let someBytes := Claim.ser (.catalog catMembers catContent (some catAsm))
@@ -134,8 +134,8 @@ def catalogClaimTests : TestSeq :=
     | .error _ => false
   test "Catalog tag is 2 bytes 0xE8 0x08"
     (someBytes.data[0]! == 0xE8 && someBytes.data[1]! == 0x08)
-  ++ test "Catalog no-asm size is 99" (noneBytes.size == 2 + 64 + 1)
-  ++ test "Catalog with-asm size is 131" (someBytes.size == 2 + 64 + 33)
+  ++ test "Catalog no-asm size is 69" (noneBytes.size == 4 + 64 + 1)
+  ++ test "Catalog with-asm size is 101" (someBytes.size == 4 + 64 + 33)
   ++ test "Catalog digest parity with Rust pin"
        (toString (Address.blake3 someBytes) == catalogDigestPin)
   ++ test "Catalog proof wrapper tag is single-byte 0xF5"
@@ -150,3 +150,4 @@ public def Tests.Claim.suite : List TestSeq := [
   catalogClaimTests,
   checkIO "Claim serde roundtrips" (∀ c : Claim, claimSerde c),
 ]
+
diff --git a/Tests/Ix/ClaimsV3.lean b/Tests/Ix/ClaimsV3.lean
new file mode 100644
index 000000000..d98f8d2ae
--- /dev/null
+++ b/Tests/Ix/ClaimsV3.lean
@@ -0,0 +1,61 @@
+module
+
+public import Ix.Resource.Claim
+public import Tests.Ix.ResourceAddressed
+public import Tests.Ix.Claim
+
+public section
+
+namespace Tests.ClaimsV3
+
+def fixtures : Array (String × Ix.Claim) :=
+  let a := Address.blake3 "a".toUTF8
+  let b := Address.blake3 "b".toUTF8
+  let asm := some (Address.blake3 "asm".toUTF8)
+  #[ ("eval", .eval a b asm), ("check", .check a none),
+     ("check_env", .checkEnv a asm), ("reveal", .reveal a (.axio none none none)),
+     ("contains", .contains a b), ("catalog", .catalog a b asm),
+     ("resource", .resource a b) ]
+
+def fixtureText : String := Id.run do
+  let mut text := "# Ixon v3 claims: name, BLAKE3, canonical bytes\n"
+  for (name, claim) in fixtures do
+    text := text ++ s!"{name}\t{Ix.Claim.commit claim}\t{hexOfBytes (Ix.Claim.ser claim)}\n"
+  return text
+
+def run : IO Unit := do
+  let expected ← IO.FS.readFile "Tests/Fixtures/ixon-v3/claims.tsv"
+  unless expected == fixtureText do throw <| IO.userError "v3 claim fixture bytes differ"
+  for (_, claim) in fixtures do
+    let bytes := Ix.Claim.ser claim
+    unless (Ix.Claim.de bytes).toOption == some claim do throw <| IO.userError "v3 claim roundtrip"
+    for n in [:bytes.size] do
+      unless (Ix.Claim.de (bytes.extract 0 n)).toOption.isNone do
+        throw <| IO.userError "truncated v3 claim accepted"
+    unless (Ix.Claim.de (bytes.push 0)).toOption.isNone do throw <| IO.userError "trailing v3 claim accepted"
+    let header := if Ix.Claim.variantOf claim >= 8 then 2 else 1
+    unless (Ix.Claim.de (bytes.set! header 2)).toOption.isNone do throw <| IO.userError "legacy claim version accepted"
+    unless (Ix.Claim.de (bytes.set! (header + 1) 255)).toOption.isNone do throw <| IO.userError "wrong validator accepted"
+    let proof : Ixon.Proof := { claim, proof := ⟨#[1, 2, 3]⟩ }
+    let proofBytes := Ixon.Proof.ser proof
+    let decoded ← IO.ofExcept (Ixon.Proof.de proofBytes)
+    unless decoded.claim == claim && decoded.proof == proof.proof do throw <| IO.userError "v3 proof roundtrip"
+    unless (Ixon.Proof.de (proofBytes.push 0)).toOption.isNone do throw <| IO.userError "trailing proof bytes accepted"
+  let (base, unit) := Tests.ResourceAddressed.unitEnv
+  let (env, _) := Tests.ResourceAddressed.store base (Tests.ResourceAddressed.identity unit)
+  let profile : Ix.Resource.Profile := {}
+  let claim ← IO.ofExcept (Ix.Resource.makeClaim env profile)
+  let _ ← IO.ofExcept (Ix.Resource.checkClaim env profile claim)
+  Tests.ResourceAddressed.check "resource claim rejects erased validator"
+    (Ix.Resource.checkClaim env profile (.checkEnv env.merkleRoot.get! none)) false
+  Tests.ResourceAddressed.check "resource claim binds the entire subject"
+    (Ix.Resource.checkClaim base profile claim) false
+  Tests.ResourceAddressed.check "resource claim binds limits"
+    (Ix.Resource.checkClaim env { profile with limits := { steps := 100001 } } claim) false
+  let result ← LSpec.lspecIO (.ofList [("v3 claims", Tests.Claim.suite)]) []
+  unless result == 0 do throw <| IO.userError "existing claim tests failed"
+  IO.println "V3 claims: fixtures, strict envelopes, proof wrappers, subjects, and profiles passed"
+
+end Tests.ClaimsV3
+
+end
diff --git a/Tests/Ix/ContractDecompile.lean b/Tests/Ix/ContractDecompile.lean
new file mode 100644
index 000000000..c6dfaf992
--- /dev/null
+++ b/Tests/Ix/ContractDecompile.lean
@@ -0,0 +1,52 @@
+module
+
+public import Ix.DecompileM
+public import Tests.Ix.ContractTransport
+
+public section
+
+namespace Tests.ContractDecompile
+
+def get (label : String) (r : Except α β) [ToString α] : IO β :=
+  match r with | .ok value => pure value | .error e => throw <| IO.userError s!"contract decompile {label}: {e}"
+
+def context : Ix.DecompileM.BlockCtx := {
+  refs := #[], univs := #[.zero], sharing := #[], mutCtx := #[], univParams := #[], arena := default }
+
+def roundtrip (expression : Ixon.Expr) : IO Unit := do
+  let (source, _) ← get "decode" <|
+    Ix.DecompileM.DecompileM.run ⟨{}⟩ context {} (Ix.DecompileM.decompileExpr expression UInt64.MAX)
+  let ((result, _), _) ← get "encode" <|
+    Ix.CompileM.CompileM.run default Tests.ContractTransport.block {} (Ix.CompileM.compileExpr source)
+  unless result == expression do throw <| IO.userError s!"contract decompile roundtrip differs: {repr expression}"
+
+def run : IO Unit := do
+  for inputBits in [:16] do
+    let some binder := Ixon.BinderContract.ofBits? inputBits.toUInt8
+      | throw <| IO.userError "invalid binder test"
+    roundtrip (.lam binder (.sort 0) (.var 0))
+    for resultBits in [:4] do
+      let some result := Ixon.ValueContract.ofBits? resultBits.toUInt8
+        | throw <| IO.userError "invalid arrow test"
+      roundtrip (.all binder result (.sort 0) (.sort 0))
+    for nonDep in [false, true] do
+      roundtrip (.letE ⟨nonDep, .value, binder⟩ (.sort 0) (.var 0) (.var 0))
+      if binder.value == .localShared then
+        roundtrip (.letE ⟨nonDep, .borrowShared, binder⟩ (.sort 0) (.var 0) (.var 0))
+  let nested := Ixon.Expr.lam ⟨.affine, .localUnique⟩ (.sort 0) (.var 0)
+  let arena : Ixon.ExprMetaArena := { nodes := #[.callSite default #[] #[] none] }
+  let ctx := { context with sharing := #[nested], arena }
+  let expression := Ixon.Expr.app (.var 0) (.share 0)
+  unless (Ix.DecompileM.DecompileM.run ⟨{}⟩ ctx {} (Ix.DecompileM.decompileExpr expression 0)).toOption.isNone do
+    throw <| IO.userError "optional replay removed a contract behind sharing"
+  let key := Ix.Name.mkStr (Ix.Name.mkStr Ix.Name.mkAnon "ix") "contract"
+  let env : Ixon.Env := { names := ({} : Std.HashMap Address Ix.Name).insert key.getHash key }
+  let arena : Ixon.ExprMetaArena := { nodes := #[.leaf, .mdata #[#[(key.getHash, .ofBool true)]] 0] }
+  let ctx := { context with arena }
+  unless (Ix.DecompileM.DecompileM.run ⟨env⟩ ctx {} (Ix.DecompileM.decompileExpr (.var 0) 1)).toOption.isNone do
+    throw <| IO.userError "optional metadata injected a semantic contract"
+  IO.println "Contract decompile: every binder, arrow, let, and borrow mode roundtrips; metadata attacks reject"
+
+end Tests.ContractDecompile
+
+end
diff --git a/Tests/Ix/ContractPipeline.lean b/Tests/Ix/ContractPipeline.lean
new file mode 100644
index 000000000..50d4cdfd0
--- /dev/null
+++ b/Tests/Ix/ContractPipeline.lean
@@ -0,0 +1,65 @@
+module
+
+public import Ix.CompileDriver
+
+public section
+
+namespace Tests.ContractPipeline
+
+open Ix.Compile
+
+def typeName : Lean.Name := `ContractA
+def identityName : Lean.Name := `contractId
+
+def typeSource : Lean.ConstantInfo := .axiomInfo {
+  name := typeName, levelParams := [], type := .sort (.succ .zero), isUnsafe := false }
+
+def identitySource : Lean.ConstantInfo := .defnInfo {
+  name := identityName, levelParams := []
+  type := .forallE `x (.const typeName []) (.const typeName []) .default
+  value := .lam `x (.const typeName []) (.bvar 0) .default
+  hints := .abbrev, safety := .safe, all := [identityName] }
+
+def input (result : Ixon.ValueContract := .localShared) : Except SourceContractError CompileInput := do
+  let contract ← SourceContract.ofTelescope identitySource #[{
+    binder := .position 0, uses := .linear, value := .localShared, result := some result }]
+  return { constants := [(typeName, typeSource), (identityName, identitySource)], contracts := #[contract] }
+
+def get (label : String) (r : Except String α) : IO α :=
+  match r with | .ok value => pure value | .error e => throw <| IO.userError s!"contract pipeline {label}: {e}"
+
+def run : IO Unit := do
+  let valid ← get "input" ((input).mapError toString)
+  let lean ← Ix.CompileM.compileLeanInput valid (numWorkers := 1) >>= get "Lean compiler"
+  let prepared ← get "preparation" valid.prepare
+  let rust ← Ix.CompileM.rsCompileEnvFFI prepared
+  let rust := rust.toEnv
+  unless (lean.env.consts.toList.map Prod.fst).mergeSort (fun a b => Address.cmpBytes a b != .gt) ==
+      (rust.consts.toList.map Prod.fst).mergeSort (fun a b => Address.cmpBytes a b != .gt) do
+    throw <| IO.userError "contract pipeline: Lean/Rust address sets differ"
+  let profile : Ix.Resource.Profile := {}
+  let explicit ← Ix.CompileM.rsCompileInput valid (some profile)
+  unless (rust.consts.toList.map Prod.fst).mergeSort (fun a b => Address.cmpBytes a b != .gt) ==
+      (explicit.consts.toList.map Prod.fst).mergeSort (fun a b => Address.cmpBytes a b != .gt) do
+    throw <| IO.userError "contract pipeline: explicit profile changed constant addresses"
+  let malformedRejected ← try
+    let _ ← Ix.CompileM.rsCompileEnvProfileFFI prepared (profile.bytes.push 0)
+    pure false
+  catch _ => pure true
+  unless malformedRejected do
+    throw <| IO.userError "contract pipeline: malformed profile bytes accepted"
+  let invalid ← get "invalid input" ((input .shared).mapError toString)
+  if (← Ix.CompileM.compileLeanInput invalid (numWorkers := 1)).toOption.isSome then
+    throw <| IO.userError "contract pipeline: pure compiler emitted an escaping local value"
+  let prepared ← get "invalid preparation" invalid.prepare
+  let rejected ← try
+    let _ ← Ix.CompileM.rsCompileEnvFFI prepared
+    pure false
+  catch _ => pure true
+  unless rejected do
+    throw <| IO.userError "contract pipeline: native compiler emitted an escaping local value"
+  IO.println "Contract pipeline: both compilers preserve addresses and reject local escape before emission"
+
+end Tests.ContractPipeline
+
+end
diff --git a/Tests/Ix/ContractTransport.lean b/Tests/Ix/ContractTransport.lean
new file mode 100644
index 000000000..77dfd2ff3
--- /dev/null
+++ b/Tests/Ix/ContractTransport.lean
@@ -0,0 +1,109 @@
+module
+
+public import Ix.Compile.SourceContract.Transport
+public import Ix.CompileM
+
+public section
+
+namespace Tests.ContractTransport
+
+open Ix.Compile
+
+def source : Lean.ConstantInfo := .defnInfo {
+  name := `contractIdentity, levelParams := []
+  type := .forallE `x (.sort .zero) (.sort .zero) .default
+  value := .lam `x (.sort .zero) (.bvar 0) .default
+  hints := .abbrev, safety := .safe, all := [`contractIdentity] }
+
+def block : Ix.CompileM.BlockEnv := ⟨{}, .mkAnon, {}, []⟩
+
+def get (label : String) (result : Except α β) [ToString α] : IO β :=
+  match result with
+  | .ok value => pure value
+  | .error error => throw <| IO.userError s!"contract transport {label}: {error}"
+
+def compileMany (sources : Array Lean.Expr) (surgical : Bool := false) :
+    Except Ix.CompileM.CompileError (Array Ixon.Expr) := do
+  let ix := Id.run ((sources.mapM Ix.CanonM.canonExpr).run' {})
+  let action := ix.mapM fun e => do
+    let (result, _) ← if surgical then Ix.CompileM.compileExprSurgical e else Ix.CompileM.compileExpr e
+    pure result
+  let (output, _) ← Ix.CompileM.CompileM.run default block {} action
+  return output
+
+def run : IO Unit := do
+  let mut sources := #[]
+  let mut expected := #[]
+  let mut allSources := #[]
+  let mut allExpected := #[]
+  for inputBits in [:16] do
+    let some binder := Ixon.BinderContract.ofBits? inputBits.toUInt8
+      | throw <| IO.userError "invalid test binder"
+    for resultBits in [:4] do
+      let some result := Ixon.ValueContract.ofBits? resultBits.toUInt8
+        | throw <| IO.userError "invalid test result"
+      let original ← get "telescope" (SourceContract.ofTelescope source #[{
+        binder := .position 0, uses := binder.uses, value := binder.value, result := some result }])
+      let resolved ← get "resolution" (original.resolve source)
+      let decorated ← get "decoration" resolved.decorate
+      allSources := allSources.push decorated.type
+      allExpected := allExpected.push (.all binder result (.sort 0) (.sort 0))
+      if resultBits == 0 then
+        let some body := sourceBody? decorated | throw <| IO.userError "missing decorated body"
+        sources := sources.push body
+        expected := expected.push (.lam binder (.sort 0) (.var 0))
+  for surgical in [false, true] do
+    let output ← get "cached lambdas" (compileMany sources surgical)
+    unless output == expected do throw <| IO.userError s!"lambda contracts collided during compilation (surgical={surgical}):\n{repr output}\nexpected {repr expected}"
+    let output ← get "cached foralls" (compileMany allSources surgical)
+    unless output == allExpected do throw <| IO.userError "arrow contracts collided during compilation"
+  -- All occurrences share their unannotated inner binder. The complete
+  -- metadata wrapper must distinguish them in both hash and equality paths.
+  for i in [:sources.size] do
+    for j in [:sources.size] do
+      let equal := Id.run ((Ix.CanonM.exprEqCached sources[i]! sources[j]!).run' {})
+      unless equal == (i == j) do throw <| IO.userError "semantic equality ignored a contract"
+  let canonical := Id.run ((sources.mapM Ix.CanonM.canonExpr).run' {})
+  for i in [:canonical.size] do
+    for j in [:canonical.size] do
+      let (comparison, _) ← get "ordering" <|
+        Ix.CompileM.CompileM.run default block {} (Ix.CompileM.compareExpr {} [] [] canonical[i]! canonical[j]!)
+      unless (comparison.ord == .eq) == (i == j) do
+        throw <| IO.userError "canonical ordering merged distinct contracts"
+  let rawLet := Lean.Expr.letE `view (.sort .zero) (.bvar 0) (.bvar 0) false
+  let borrow : Ix.SemanticContract.Contract := {
+    kind := .letE, binder := ⟨.affine, .localShared⟩, letKind := .borrowShared }
+  let annotated := borrow.attach rawLet
+  for surgical in [false, true] do
+    let output ← get "borrow lowering" (compileMany #[rawLet, annotated, rawLet] surgical)
+    let expectedBorrow := Ixon.Expr.letE ⟨false, .borrowShared, ⟨.affine, .localShared⟩⟩ (.sort 0) (.var 0) (.var 0)
+    unless output == #[.leanLet false (.sort 0) (.var 0) (.var 0), expectedBorrow,
+      .leanLet false (.sort 0) (.var 0) (.var 0)] do
+      throw <| IO.userError "borrow contract contaminated a shared ordinary cache entry"
+  let wrong := borrow.attach (.sort .zero)
+  unless (compileMany #[wrong]).toOption.isNone do
+    throw <| IO.userError "semantic metadata on a non-binder was discarded"
+  let malformed := Lean.Expr.mdata (({} : Lean.MData).setNat `ix.contract 3) (.sort .zero)
+  unless (compileMany #[malformed]).toOption.isNone do
+    throw <| IO.userError "malformed semantic metadata was discarded"
+  let inner := Lean.Expr.lam `x (.sort .zero) (.bvar 0) .default
+  let nestedSource : Lean.ConstantInfo := .defnInfo {
+    name := `nested, levelParams := [], type := .sort .zero
+    value := .app inner inner, hints := .abbrev, safety := .safe, all := [`nested] }
+  let nestedContract : SourceContract := {
+    source := nestedSource
+    binders := #[
+      { site := ⟨.body, [.appFn]⟩, uses := .linear },
+      { site := ⟨.body, [.appArg]⟩, uses := .affine, value := .localUnique }] }
+  let nested ← get "nested resolution" (nestedContract.resolve nestedSource)
+  let nested ← get "nested decoration" nested.decorate
+  let some body := sourceBody? nested | throw <| IO.userError "missing nested body"
+  let output ← get "nested lowering" (compileMany #[body])
+  unless output == #[.app (.lam ⟨.linear, .shared⟩ (.sort 0) (.var 0))
+      (.lam ⟨.affine, .localUnique⟩ (.sort 0) (.var 0))] do
+    throw <| IO.userError "occurrence contracts merged before canonicalization"
+  IO.println "Contract transport: every binder/arrow mode, cache ordering, nested occurrences, and borrow lowering passed"
+
+end Tests.ContractTransport
+
+end
diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean
index 54d281f95..95eee1fef 100644
--- a/Tests/Ix/IxVM.lean
+++ b/Tests/Ix/IxVM.lean
@@ -436,91 +436,92 @@ private def nameOfString (str : String) : Lean.Name :=
 /-- Exact FFT-cost pins, one per checked constant. These are equality
     assertions, not budgets: any kernel change that shifts the cost of a
     listed constant fails the suite, so a regression cannot land quietly
-    and an improvement has to be acknowledged by re-pinning. -/
+    and an improvement has to be acknowledged by re-pinning. These pins
+    include v3 contract decoding, canonicality checks, and scoped claim headers. -/
 private def kernelCheckEntries : List (String × Nat) := [
-  ("HEq",                                                        129_564_240),
-  ("HEq.rec",                                                    133_635_391),
-  ("Eq.rec",                                                     133_021_745),
-  ("Nat",                                                        129_623_366),
-  ("Nat.add",                                                    170_150_714),
-  ("Nat.add_comm",                                               321_012_193),
-  ("Nat.decEq",                                                  374_661_095),
-  ("Nat.decLe",                                                  809_087_220),
-  ("Nat.sub_le_of_le_add",                                     1_940_123_694),
-  ("Nat.shiftRight_succ",                                      1_444_882_493),
-  ("Trans.mk",                                                   137_045_209),
-  ("Array.append_assoc",                                       8_966_849_183),
-  ("Vector.append",                                            9_171_695_055),
-  ("IxVMPrim.nat_add_lit",                                       212_861_619),
-  ("IxVMPrim.nat_sub_lit",                                       227_386_846),
-  ("IxVMPrim.nat_mul_lit",                                       203_299_494),
-  ("IxVMPrim.nat_mul_big",                                       201_802_184),
-  ("IxVMPrim.nat_div_lit",                                     1_408_970_337),
-  ("IxVMPrim.nat_mod_lit",                                     1_436_098_628),
-  ("IxVMPrim.nat_succ_lit",                                      144_238_558),
-  ("IxVMPrim.nat_pred_lit",                                      165_925_581),
-  ("IxVMPrim.nat_gcd_lit",                                     2_212_674_185),
-  ("IxVMPrim.nat_land_lit",                                    3_626_697_684),
-  ("IxVMPrim.nat_lor_lit",                                     3_628_832_434),
-  ("IxVMPrim.nat_xor_lit",                                     3_648_148_999),
-  ("IxVMPrim.nat_shl_lit",                                       232_948_252),
-  ("IxVMPrim.nat_shr_lit",                                     1_424_376_423),
-  ("IxVMPrim.nat_pow_big",                                       395_061_882),
-  ("IxVMPrim.nat_beq_lit",                                       200_818_038),
-  ("IxVMPrim.nat_ble_lit",                                       196_263_482),
-  ("IxVMPrim.nat_cases_big",                                     166_114_980),
-  ("IxVMPrim.nat_dec_le",                                        827_119_382),
-  ("IxVMPrim.nat_dec_lt",                                        838_745_284),
-  ("IxVMPrim.nat_dec_eq",                                        414_096_843),
-  ("IxVMPrim.str_size_lit",                                    2_544_207_447),
-  ("IxVMPrim.bv_to_nat_lit",                                   2_117_185_422),
-  ("IxVMInd.Even",                                               206_713_282),
-  ("IxVMInd.Odd",                                                206_718_095),
-  ("IxVMInd.Even.rec",                                           225_635_286),
-  ("IxVMInd.Odd.rec",                                            225_634_357),
-  ("IxVMInd.IdxTeleN.rec",                                       160_889_521),
-  ("IxVMInd.IdxTeleB.rec",                                       160_887_830),
-  ("IxVMInd.SoloA.rec",                                          156_053_377),
-  ("IxVMInd.SoloB.rec",                                          156_052_541),
-  ("IxVMInd.UnsafeSquash",                                       131_450_175),
-  ("IxVMInd.Tree",                                               131_240_841),
-  ("IxVMInd.Tree.rec",                                           141_974_179),
-  ("IxVMInd.DedupM",                                             134_584_644),
-  ("IxVMInd.DedupM.rec",                                         148_962_853),
-  ("IxVMInd.DepthM",                                             132_979_973),
-  ("IxVMInd.DepthM.rec",                                         144_480_203),
-  ("String.Internal.append",                                   2_514_512_630),
-  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_718_640_130),
-  ("Lean.Syntax.rec",                                          2_577_034_533),
-  ("IxVMInd.AuxTie",                                             324_922_647),
-  ("IxVMInd.AuxTie.rec",                                         370_715_895),
-  ("IxVMInd.HiddenIdx",                                          130_539_387),
-  ("IxVMInd.HiddenIdx.rec",                                      133_900_992),
-  ("IxVMInd.thmMajorUse",                                        514_568_311),
-  ("IxVMInd.partialKRec",                                        150_213_472),
-  ("IxVMInd.deepRebase",                                         221_439_841),
-  ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec",        3_494_729_338),
-  ("Lean.Widget.TaggedText.rec",                               2_546_187_448),
-  ("Lean.Doc.Part.rec",                                        2_591_677_855),
-  ("Lean.Doc.Block.rec",                                       2_824_614_457),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_550_989),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_197_600),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_104_547),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_104_547),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_104_547),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_846_298),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 144_852_729),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 144_851_147),
-  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_104_547),
-  ("strOfListFoldSize",                                        2_828_073_789),
-  ("strOfListFoldSizeAscii",                                   2_828_919_123),
-  ("IxVMPrim.lazy_ble_offset",                                   234_099_077),
-  ("IxVMPrim.lazy_unit_cast",                                    553_552_538),
-  ("IxVMPrim.sizeof_unit",                                       160_924_895),
-  ("IxVMPerf.let_continuations",                                 163_786_903),
-  ("IxVMPerf.mul_row",                                           421_263_950),
-  ("IxVMPerf.context_tower",                                     514_451_931),
-  ("IxVMPerf.mul_wide",                                          267_049_336),
+  ("HEq",                                                        129_580_132),
+  ("HEq.rec",                                                    133_703_388),
+  ("Eq.rec",                                                     133_072_615),
+  ("Nat",                                                        129_633_587),
+  ("Nat.add",                                                    170_479_894),
+  ("Nat.add_comm",                                               322_598_714),
+  ("Nat.decEq",                                                  377_100_753),
+  ("Nat.decLe",                                                  814_998_141),
+  ("Nat.sub_le_of_le_add",                                     1_957_472_572),
+  ("Nat.shiftRight_succ",                                      1_455_068_309),
+  ("Trans.mk",                                                   137_107_353),
+  ("Array.append_assoc",                                       9_081_433_824),
+  ("Vector.append",                                            9_287_002_309),
+  ("IxVMPrim.nat_add_lit",                                       213_488_292),
+  ("IxVMPrim.nat_sub_lit",                                       228_506_721),
+  ("IxVMPrim.nat_mul_lit",                                       204_344_721),
+  ("IxVMPrim.nat_mul_big",                                       202_896_358),
+  ("IxVMPrim.nat_div_lit",                                     1_420_411_368),
+  ("IxVMPrim.nat_mod_lit",                                     1_447_938_067),
+  ("IxVMPrim.nat_succ_lit",                                      144_339_930),
+  ("IxVMPrim.nat_pred_lit",                                      166_168_846),
+  ("IxVMPrim.nat_gcd_lit",                                     2_232_501_380),
+  ("IxVMPrim.nat_land_lit",                                    3_652_583_530),
+  ("IxVMPrim.nat_lor_lit",                                     3_654_583_905),
+  ("IxVMPrim.nat_xor_lit",                                     3_674_202_062),
+  ("IxVMPrim.nat_shl_lit",                                       234_243_500),
+  ("IxVMPrim.nat_shr_lit",                                     1_435_151_445),
+  ("IxVMPrim.nat_pow_big",                                       395_904_832),
+  ("IxVMPrim.nat_beq_lit",                                       201_412_466),
+  ("IxVMPrim.nat_ble_lit",                                       196_817_405),
+  ("IxVMPrim.nat_cases_big",                                     166_401_353),
+  ("IxVMPrim.nat_dec_le",                                        833_212_679),
+  ("IxVMPrim.nat_dec_lt",                                        844_424_937),
+  ("IxVMPrim.nat_dec_eq",                                        416_937_906),
+  ("IxVMPrim.str_size_lit",                                    2_563_571_976),
+  ("IxVMPrim.bv_to_nat_lit",                                   2_135_250_014),
+  ("IxVMInd.Even",                                               206_886_515),
+  ("IxVMInd.Odd",                                                206_892_115),
+  ("IxVMInd.Even.rec",                                           226_129_215),
+  ("IxVMInd.Odd.rec",                                            226_131_072),
+  ("IxVMInd.IdxTeleN.rec",                                       161_370_130),
+  ("IxVMInd.IdxTeleB.rec",                                       161_368_435),
+  ("IxVMInd.SoloA.rec",                                          156_211_923),
+  ("IxVMInd.SoloB.rec",                                          156_211_088),
+  ("IxVMInd.UnsafeSquash",                                       131_473_733),
+  ("IxVMInd.Tree",                                               131_267_145),
+  ("IxVMInd.Tree.rec",                                           142_162_255),
+  ("IxVMInd.DedupM",                                             134_625_951),
+  ("IxVMInd.DedupM.rec",                                         149_282_091),
+  ("IxVMInd.DepthM",                                             133_016_231),
+  ("IxVMInd.DepthM.rec",                                         144_730_870),
+  ("String.Internal.append",                                   2_533_658_506),
+  ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 3_750_129_764),
+  ("Lean.Syntax.rec",                                          2_597_021_992),
+  ("IxVMInd.AuxTie",                                             326_741_066),
+  ("IxVMInd.AuxTie.rec",                                         373_345_395),
+  ("IxVMInd.HiddenIdx",                                          130_558_032),
+  ("IxVMInd.HiddenIdx.rec",                                      133_948_354),
+  ("IxVMInd.thmMajorUse",                                        517_920_579),
+  ("IxVMInd.partialKRec",                                        150_421_901),
+  ("IxVMInd.deepRebase",                                         221_891_341),
+  ("String.Slice.Pattern.Model.NoPrefixPatternModel.rec",        3_515_782_465),
+  ("Lean.Widget.TaggedText.rec",                               2_566_008_609),
+  ("Lean.Doc.Part.rec",                                        2_611_709_383),
+  ("Lean.Doc.Block.rec",                                       2_847_867_384),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A", 132_585_241),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec", 136_255_212),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_1", 135_184_337),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup1.A.rec_2", 135_184_337),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedup2.A.rec_1", 135_184_337),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M", 132_875_994),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec", 145_089_906),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_1", 145_088_324),
+  ("_private.Tests.Ix.Compile.Mutual.0.Tests.Ix.Compile.Mutual.AuxDedupMixed.M.rec_2", 135_184_337),
+  ("strOfListFoldSize",                                        2_848_829_120),
+  ("strOfListFoldSizeAscii",                                   2_849_606_441),
+  ("IxVMPrim.lazy_ble_offset",                                   234_904_821),
+  ("IxVMPrim.lazy_unit_cast",                                    558_233_712),
+  ("IxVMPrim.sizeof_unit",                                       161_110_680),
+  ("IxVMPerf.let_continuations",                                 165_727_825),
+  ("IxVMPerf.mul_row",                                           424_822_409),
+  ("IxVMPerf.context_tower",                                     518_991_146),
+  ("IxVMPerf.mul_wide",                                          268_439_307),
 ]
 
 /-- Variant of `kernelChecks`, pinned to the baseline
@@ -657,7 +658,7 @@ public def claimRevealDefnExpr (ixonEnv : Ixon.Env) : IO AiurTestCase := do
     (Ix.Claim.reveal comm revealInfo) {}
   pure (asTestCase "Claim Reveal Defn (typ Expr addr)" witness)
 
-/-- Reveal the type hash of a hand-built v2 expression carrying every
+/-- Reveal the type hash of a hand-built v3 expression carrying every
     non-conservative binder feature that ordinary Lean compilation cannot yet
     produce. This is the positive end-to-end guard that the circuit preserves
     mode bytes while parsing and reproduces them in `expr_addr`; conversion may
@@ -674,7 +675,7 @@ public def claimRevealBinderModes : IO AiurTestCase := do
   let typAddr := Address.blake3 (Ixon.runPut (Ixon.putExpr typ))
   let witness ← IO.ofExcept <| buildClaimWitness ixonEnv
     (Ix.Claim.reveal addr (.axio none none (some typAddr))) {}
-  pure (asTestCase "Claim Reveal Expr (v2 binder modes)" witness)
+  pure (asTestCase "Claim Reveal Expr (v3 binder modes)" witness)
 
 /-- the kernel `Reveal` CPrj — all projection fields. coverage. -/
 public def claimRevealCPrj (ixonEnv : Ixon.Env) : IO AiurTestCase := do
diff --git a/Tests/Ix/IxVM/Exploits.lean b/Tests/Ix/IxVM/Exploits.lean
index 33419a0a7..ff564a074 100644
--- a/Tests/Ix/IxVM/Exploits.lean
+++ b/Tests/Ix/IxVM/Exploits.lean
@@ -164,7 +164,7 @@ def bothUsedTarget : Ixon.Env × Address := Id.run do
   -- string.
   let env := { env with blobs := env.blobs.insert badAddr (Ixon.ser illTypedConst) }
   let target := defnConst .defn prop
-    (.letE false prop (.nat 0) (.ref 0 #[])) #[] #[badAddr] univsZero
+    (.letE (.lean false) prop (.nat 0) (.ref 0 #[])) #[] #[badAddr] univsZero
   storeAt env target
 
 /-- A definition whose declared type is `String` and whose value is a
@@ -943,15 +943,15 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address)
   let (nestedAppEnv, nestedAppAddr) :=
     rawExpr #[0x71, 0x71, 0x10, 0x11, 0x12]
   let (nestedLamEnv, nestedLamAddr) :=
-    rawExpr #[0x81, 0x03, 0x00, 0x81, 0x03, 0x00, 0x10]
+    rawExpr #[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10]
   let (nestedAllEnv, nestedAllAddr) :=
-    rawExpr #[0x91, 0x07, 0x00, 0x91, 0x07, 0x00, 0x10]
+    rawExpr #[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10]
   let (badLetFlagEnv, badLetFlagAddr) :=
-    rawExpr #[0xA2, 0x00, 0x00, 0x00]
+    rawExpr #[0xA4, 0x07, 0x00, 0x00, 0x00]
   let (badLamModeEnv, badLamModeAddr) :=
-    rawExpr #[0x81, 0x04, 0x00, 0x10]
+    rawExpr #[0x81, 0x10, 0x00, 0x10]
   let (badAllModeEnv, badAllModeAddr) :=
-    rawExpr #[0x91, 0x08, 0x00, 0x10]
+    rawExpr #[0x91, 0x40, 0x00, 0x10]
   -- `Inner α | mk : α → Inner α` — α strictly positive. `Host` is fine.
   let (posEnv, posAddr) := nestedHost base #[] (.var 0)
   -- `Inner α | mk : (α → False) → Inner α` — α NEGATIVE. Substituting
@@ -1428,12 +1428,12 @@ def cases (base : Ixon.Env) (strAddr falseAddr : Address)
         forall"
       env := nestedAllEnv
       claim := .reveal nestedAllAddr (.axio none none none) },
-    { name := "non-boolean-let-flag"
-      intent := "Reveal rejects a Let whose Tag4 size is neither 0 nor 1"
+    { name := "invalid-let-flags"
+      intent := "Reveal rejects a Let whose Tag4 size exceeds the two v3 flag bits"
       env := badLetFlagEnv
       claim := .reveal badLetFlagAddr (.axio none none none) },
     { name := "invalid-lambda-mode"
-      intent := "Reveal rejects a lambda usage byte outside 0..3"
+      intent := "Reveal rejects reserved bits above the four-bit lambda contract"
       env := badLamModeEnv
       claim := .reveal badLamModeAddr (.axio none none none) },
     { name := "invalid-forall-mode"
diff --git a/Tests/Ix/Ixon.lean b/Tests/Ix/Ixon.lean
index 6eeb08645..580b1a8cb 100644
--- a/Tests/Ix/Ixon.lean
+++ b/Tests/Ix/Ixon.lean
@@ -111,8 +111,8 @@ def exprUnits : TestSeq :=
     .all .many .shared (.sort 0) (.var 0),
     .all .linear .unique (.sort 0)
       (.all .erased .shared (.sort 1) (.var 0)),  -- Nested alls (telescope)
-    .letE true (.sort 0) (.var 0) (.var 1),
-    .letE false (.sort 0) (.var 0) (.var 1),
+    .letE (.lean true) (.sort 0) (.var 0) (.var 1),
+    .letE (.lean false) (.sort 0) (.var 0) (.var 1),
     .prj 0 1 (.var 0),
   ]
   cases.foldl (init := .done) fun acc e =>
diff --git a/Tests/Ix/IxonSyntax.lean b/Tests/Ix/IxonSyntax.lean
index d769d93f0..b6e9c9ead 100644
--- a/Tests/Ix/IxonSyntax.lean
+++ b/Tests/Ix/IxonSyntax.lean
@@ -90,6 +90,8 @@ def termCorpus : List String := [
   "(x : Nat) → Vec x",
   "(x y : Nat) (z : Bool) → f x y z",
   "Nat → Bool",
+  "(10767821210224983288 → ! B) a",
+  "A → 17932781577842061186",
   "Nat → Bool → Prop",
   "(Nat → Bool) → Prop",
   "let x : Nat := 5; f x",
@@ -134,7 +136,7 @@ def isUnaryApp : Term → Bool
   | _ => false
 
 def isLet (nonDep : Bool) : Term → Bool
-  | .letE nd .. => nd == nonDep
+  | .letE contract .. => contract.nonDep == nonDep
   | _ => false
 
 def adjacencyIsSignificant : TestSeq :=
@@ -160,13 +162,13 @@ def letVsHave : TestSeq :=
 /-- The acceptance fixture: hand-formatted input normalizes to the
     SAME canonical bytes the Rust printer emits (shared golden). -/
 def acceptanceFixture : TestSeq :=
-  let src := "ixon 1\n"
+  let src := "ixon 3\n"
     ++ "import #9c41aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9c41\n"
     ++ "\n"
     ++ "def : String → Except PatchError String :=\n"
     ++ "  fun (s : String) => Except.ok PatchError String s\n"
   let canonical :=
-    "import #9c41aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9c41\n"
+    "ixon 3\n\nimport #9c41aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9c41\n"
     ++ "\n"
     ++ "def : String → Except PatchError String := "
     ++ "fun (s : String) => Except.ok PatchError String s\n"
@@ -177,7 +179,7 @@ def acceptanceFixture : TestSeq :=
       (printed == canonical)
 
 def kitchenSink : TestSeq :=
-  let src := "ixon 1
+  let src := "ixon 3
 
 import #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 import Std.V2#bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
@@ -224,68 +226,51 @@ def rtFileEq (src expect : String) : Bool :=
   | .error _ => false
 
 def mainExpression : TestSeq :=
-  test "minimal main-only file is canonical (no header)"
-    (rtFileEq "⊢ 1 : Nat\n" "⊢ 1 : Nat\n")
-  ++ test "explicit ixon 1 header accepted and canonically omitted"
-    (rtFileEq "ixon 1\n⊢ 1 : Nat\n" "⊢ 1 : Nat\n")
-  ++ test "ASCII turnstile normalizes to ⊢"
-    (rtFileEq "|- 1 : Nat\n" "⊢ 1 : Nat\n")
-  ++ test "low-precedence values parenthesize canonically"
-    (rtFileEq "⊢ fun (x : Nat) => x : Nat → Nat\n"
-      "⊢ (fun (x : Nat) => x) : Nat → Nat\n")
+  let cases : List (String × String) := [
+    ("⊢ 1 : Nat\n", "⊢ 1 : Nat\n"),
+    ("|- 1 : Nat\n", "⊢ 1 : Nat\n"),
+    ("1 : Nat\n", "⊢ 1 : Nat\n"),
+    ("⊢ fun (x : Nat) => x : Nat → Nat\n", "⊢ (fun (x : Nat) => x) : Nat → Nat\n"),
+    ("ixon : Nat\n", "⊢ ixon : Nat\n"),
+    ("fun (s : String) => Except.ok PatchError String s : String -> Except PatchError String\n",
+      "⊢ (fun (s : String) => Except.ok PatchError String s) : String → Except PatchError String\n"),
+    ("import #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfun (x : Nat) => x : Nat → Nat\n",
+      "import #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\n⊢ (fun (x : Nat) => x) : Nat → Nat\n")]
+  let formats := cases.foldl (init := .done) fun tests (src, expected) =>
+    tests ++ test s!"v3 main {repr src}"
+      (rtFileEq ("ixon 3\n" ++ src) ("ixon 3\n\n" ++ expected))
+  formats
   ++ test "the annotation is mandatory"
-    (errKind (parseFile "⊢ 1\n") fun k =>
-      match k with
-      | .unexpectedToken .. => true
-      | _ => false)
-  ++ test "bare form accepted as the file's sole item"
-    (rtFileEq "1 : Nat\n" "⊢ 1 : Nat\n")
-  ++ test "bare form after imports"
-    (rtFileEq
-      ("import "
-        ++ "#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
-        ++ "fun (x : Nat) => x : Nat → Nat\n")
-      ("import "
-        ++ "#aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\n"
-        ++ "⊢ (fun (x : Nat) => x) : Nat → Nat\n"))
-  ++ test "leading ixon without a numeral is content"
-    (rtFileEq "ixon : Nat\n" "⊢ ixon : Nat\n")
-  ++ test "the fully minimal wire: one bare judgment"
-    (rtFileEq
-      ("fun (s : String) => Except.ok PatchError String s : "
-        ++ "String -> Except PatchError String\n")
-      ("⊢ (fun (s : String) => Except.ok PatchError String s) : "
-        ++ "String → Except PatchError String\n"))
+    (errKind (parseFile "ixon 3\n⊢ 1\n") fun k =>
+      match k with | .unexpectedToken .. => true | _ => false)
   ++ test "after a declaration the turnstile is required"
-    (errKind (parseFile "ixon 1\ndef x : N := v\n1 : Nat\n") fun k =>
-      match k with
-      | .unexpectedToken .. => true
-      | _ => false)
+    (errKind (parseFile "ixon 3\ndef x : N := v\n1 : Nat\n") fun k =>
+      match k with | .unexpectedToken .. => true | _ => false)
   ++ test "at most one main expression"
-    (errKind (parseFile "ixon 1\n⊢ 1 : Nat ⊢ 2 : Nat\n")
-      (· == .mainExprNotLast))
+    (errKind (parseFile "ixon 3\n⊢ 1 : Nat ⊢ 2 : Nat\n") (· == .mainExprNotLast))
   ++ test "main expression must be last"
-    (errKind (parseFile "ixon 1\n⊢ 1 : Nat def x : A := b\n")
-      (· == .mainExprNotLast))
+    (errKind (parseFile "ixon 3\n⊢ 1 : Nat def x : A := b\n") (· == .mainExprNotLast))
 
 def mainAfterTermFinalDecl : TestSeq :=
   -- Regression (found by quickcheck on the Rust side): the turnstile
   -- stops the preceding declaration's application spine.
   checkExcept "main after where-less inductive"
     (roundtripFile
-      "ixon 1\ninductive N (params := 0) (indices := 0) : Prop\n\n⊢ Prop : Prop\n")
+      "ixon 3\ninductive N (params := 0) (indices := 0) : Prop\n\n⊢ Prop : Prop\n")
   ++ checkExcept "|- after a ctor block is not eaten by the bar"
     (roundtripFile
-      ("ixon 1\ninductive N (params := 0) (indices := 0) : Prop where\n"
+      ("ixon 3\ninductive N (params := 0) (indices := 0) : Prop where\n"
         ++ "  | c (params := 0) (fields := 0) : N\n|- c : N\n"))
 
 def versionGate : TestSeq :=
-  test "ixon 2 rejected"
-    (errKind (parseFile "ixon 2\n") fun k => k == .unknownVersion 2 1)
+  ([1, 2, 4] : List Nat).foldl (init :=
+      test "version header required" (errKind (parseFile "⊢ 1 : Nat\n") (fun _ => true)))
+    fun tests version => tests ++ test s!"ixon {version} rejected"
+      (errKind (parseFile s!"ixon {version}\n") (· == .unknownVersion version 3))
 
 def importHashLength : TestSeq :=
   test "short import hash rejected"
-    (errKind (parseFile "ixon 1\nimport #abcd\n")
+    (errKind (parseFile "ixon 3\nimport #abcd\n")
       fun k => k == .importHashLength 4)
 
 def errorShapes : TestSeq :=
@@ -309,7 +294,7 @@ def errorShapes : TestSeq :=
   ++ test "empty levels"
     (errKind (parseTerm "Nat.{}") (· == .emptyLevels))
   ++ test "line/col are 1-based"
-    (errLine (parseFile "ixon 1\ndef x : Nat :=\n") 3)
+    (errLine (parseFile "ixon 3\ndef x : Nat :=\n") 3)
 
 def depthCap : TestSeq :=
   let limits : Limits := { maxDepth := 16 }
diff --git a/Tests/Ix/IxonV3.lean b/Tests/Ix/IxonV3.lean
new file mode 100644
index 000000000..bf0e54592
--- /dev/null
+++ b/Tests/Ix/IxonV3.lean
@@ -0,0 +1,124 @@
+module
+public import Ix.Ixon
+public import Ix.Sharing
+
+public section
+
+namespace Tests.IxonV3
+open Ixon
+
+structure ExprCase where
+  name : String
+  expr : Expr
+  bytes : ByteArray
+
+def lambdaTelescope : Expr :=
+  .lam .many (.sort 0) (.lam .many (.sort 0) (.lam .many (.sort 0) (.var 0)))
+
+def fixtures : List (String × Expr) := [
+  ("app", .app (.app (.app (.var 3) (.var 2)) (.var 1)) (.var 0)),
+  ("lam", lambdaTelescope),
+  ("lam_local_unique", .lam ⟨.linear, .localUnique⟩ (.sort 0) (.var 0)),
+  ("lam_affine_local", .lam ⟨.affine, .localShared⟩ (.sort 0) (.var 0)),
+  ("all", .all ⟨.linear, .localUnique⟩ .localUnique (.sort 0)
+    (.all .many .shared (.sort 0) (.var 0))),
+  ("ordinary_let", .letE ⟨true, .value, ⟨.erased, .unique⟩⟩ (.sort 0) (.nat 1) (.var 0)),
+  ("local_unique_let", .letE ⟨false, .value, ⟨.affine, .localUnique⟩⟩ (.sort 0) (.var 1) (.var 0)),
+  ("borrow", .letE (.borrow false .affine) (.sort 0) (.prj 2 1 (.var 1)) (.var 0)),
+  ("borrow_nondep", .letE (.borrow true .many) (.sort 0) (.var 1) (.var 0)),
+  ("reference", .ref 0 #[]),
+  ("recursion", .recur 2 #[0, 1])
+]
+
+def valueContracts : Array ValueContract := #[.unique, .shared, .localUnique, .localShared]
+def usages : Array Uses := #[.erased, .linear, .affine, .many]
+
+/-- Every representable combination. Resource validity is checked separately
+from these representation tests, including for borrow-let contracts. -/
+def modeCases : List ExprCase := Id.run do
+  let mut cases := #[]
+  for v in [:4] do
+    for u in [:4] do
+      let contract : BinderContract := ⟨usages[u]!, valueContracts[v]!⟩
+      let code := (u + 4 * v).toUInt8
+      cases := cases.push ⟨s!"lambda-{u}-{v}", .lam contract (.sort 0) (.var 0),
+        ByteArray.mk #[0x81, code, 0x00, 0x10]⟩
+      for r in [:4] do
+        cases := cases.push ⟨s!"forall-{u}-{v}-{r}",
+          .all contract valueContracts[r]! (.sort 0) (.var 0),
+          ByteArray.mk #[0x91, code + 16 * r.toUInt8, 0x00, 0x10]⟩
+      for flags in [:4] do
+        let lc : LetContract := {
+          nonDep := flags % 2 == 1
+          kind := if flags / 2 == 1 then .borrowShared else .value
+          binder := contract
+        }
+        cases := cases.push ⟨s!"let-{u}-{v}-{flags}", .letE lc (.sort 0) (.var 1) (.var 0),
+          ByteArray.mk #[0xA0 + flags.toUInt8, code, 0x00, 0x11, 0x10]⟩
+  return cases.toList
+
+/-- Load independent golden bytes once for the Lean, Rust FFI, and VM suites. -/
+def readExprCases : IO (List ExprCase) := do
+  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/expressions.txt"
+  let lines := file.splitOn "\n"
+  let golden : List ExprCase ← fixtures.mapM fun (name, expr) => do
+    let some line := lines.find? (·.startsWith (name ++ " "))
+      | throw <| IO.userError s!"missing fixture {name}"
+    let [_, hex] := line.splitOn " "
+      | throw <| IO.userError s!"invalid fixture row: {line}"
+    let some bytes := bytesOfHex hex
+      | throw <| IO.userError s!"invalid fixture hex: {name}"
+    return { name, expr, bytes }
+  return golden ++ modeCases
+
+def checkBytes (name : String) (expr : Expr) (expected : ByteArray) : IO Nat := do
+  let actual := runPut (putExpr expr)
+  unless actual == expected do
+    throw <| IO.userError s!"{name}: bytes {hexOfBytes actual} != {hexOfBytes expected}"
+  match runGetExact getExpr expected with
+  | .ok decoded => unless decoded == expr do
+      throw <| IO.userError s!"{name}: decoded expression differs"
+  | .error e => throw <| IO.userError s!"{name}: {e}"
+  if (runGetExact getExpr (expected.push 0)).toOption.isSome then
+    throw <| IO.userError s!"{name}: accepted trailing byte"
+  for n in [0:expected.size] do
+    if (runGetExact getExpr (expected.extract 0 n)).toOption.isSome then
+      throw <| IO.userError s!"{name}: accepted truncation at {n}"
+  return expected.size + 3
+
+def malformedCases : Array (String × ByteArray) := #[
+  ("empty-app", .mk #[0x70]),
+  ("empty-lambda", .mk #[0x80]),
+  ("empty-forall", .mk #[0x90]),
+  ("split-app-telescope", .mk #[0x71, 0x71, 0x10, 0x11, 0x12]),
+  ("split-lambda-telescope", .mk #[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10]),
+  ("split-forall-telescope", .mk #[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10]),
+  ("reserved-let-flags", .mk #[0xA4, 0x07, 0x00, 0x10, 0x10]),
+  ("nonminimal-variable", .mk #[0x18, 0x00]),
+  ("nonminimal-reference-count", .mk #[0x28, 0x07, 0x00]),
+  ("nonminimal-reference-index", .mk #[0x20, 0x80, 0x00]),
+  ("truncated-lambda-telescope", .mk #[0x87, 0x07, 0x00, 0x10]),
+  ("truncated-app-telescope", .mk #[0x77, 0x10])
+]
+
+/-- Shared raw rejection cases for the native Lean decoder and VM. -/
+def rejectedExprCases : Array (String × ByteArray) := Id.run do
+  let mut cases := malformedCases
+  for code in [16:256] do
+    cases := cases.push (s!"lambda-reserved-binder-{code}", .mk #[0x81, code.toUInt8, 0x00, 0x10])
+    cases := cases.push (s!"let-reserved-binder-{code}", .mk #[0xA0, code.toUInt8, 0x00, 0x10, 0x10])
+  for code in [64:256] do
+    cases := cases.push (s!"forall-reserved-bits-{code}", .mk #[0x91, code.toUInt8, 0x00, 0x10])
+  return cases
+
+def runGolden (cases : List ExprCase) : IO Nat := do
+  let mut checks := 0
+  for test in cases do
+    checks := checks + (← checkBytes test.name test.expr test.bytes)
+  for (name, bytes) in rejectedExprCases do
+    if (runGetExact getExpr bytes).toOption.isSome then
+      throw <| IO.userError s!"{name}: accepted noncanonical bytes {hexOfBytes bytes}"
+    checks := checks + 1
+  return checks
+
+end Tests.IxonV3
diff --git a/Tests/Ix/IxonV3FFI.lean b/Tests/Ix/IxonV3FFI.lean
new file mode 100644
index 000000000..6c0f16af2
--- /dev/null
+++ b/Tests/Ix/IxonV3FFI.lean
@@ -0,0 +1,43 @@
+module
+public import Tests.Ix.IxonV3
+
+public section
+namespace Tests.IxonV3
+open Ixon
+
+@[extern "rs_roundtrip_ixon_expr"] opaque roundtripExpr : @& Expr → Expr
+@[extern "rs_roundtrip_ixon_constant"] opaque roundtripConstant : @& Constant → Constant
+@[extern "rs_eq_expr_serialization"] opaque equalExprBytes : @& Expr → @& ByteArray → Bool
+@[extern "rs_eq_constant_serialization"] opaque equalConstantBytes : @& Constant → @& ByteArray → Bool
+@[extern "rs_expr_hash_matches"] opaque equalSharingHash : @& Expr → @& Address → Bool
+
+def runFFI (cases : List ExprCase) : IO Nat := do
+  let mut checks := 0
+  for ⟨name, expr, _⟩ in cases do
+    unless roundtripExpr expr == expr do
+      throw <| IO.userError s!"{name}: FFI roundtrip differs"
+    unless equalExprBytes expr (runPut (putExpr expr)) do
+      throw <| IO.userError s!"{name}: Lean/Rust bytes differ"
+    unless equalSharingHash expr (Ix.Sharing.computeExprHash expr) do
+      throw <| IO.userError s!"{name}: Lean/Rust sharing hash differs"
+    checks := checks + 3
+  let typ := Expr.all ⟨.linear, .localUnique⟩ .localShared (.sort 0) (.sort 0)
+  let value := lambdaTelescope
+  let ctor : Constructor := ⟨true, 5, 1, 2, 3, typ⟩
+  let ind : Inductive := ⟨false, 5, 2, 3, typ, #[ctor]⟩
+  let recr : Recursor := ⟨true, false, 5, 1, 2, 3, 4, typ, #[⟨3, value⟩]⟩
+  let defn : Definition := ⟨.opaq, .part, 5, typ, value⟩
+  let infos : Array (String × ConstantInfo) := #[
+    ("definition", .defn defn), ("recursor", .recr recr),
+    ("axiom", .axio ⟨true, 5, typ⟩), ("quotient", .quot ⟨.lift, 5, typ⟩),
+    ("mutual", .muts #[.defn defn, .indc ind, .recr recr])]
+  for (name, info) in infos do
+    let c : Constant := ⟨info, #[value], #[], #[.zero]⟩
+    unless roundtripConstant c == c do
+      throw <| IO.userError s!"{name}: declaration FFI roundtrip differs"
+    unless equalConstantBytes c (serConstant c) do
+      throw <| IO.userError s!"{name}: declaration Lean/Rust bytes differ"
+    checks := checks + 2
+  return checks
+
+end Tests.IxonV3
diff --git a/Tests/Ix/IxonV3Text.lean b/Tests/Ix/IxonV3Text.lean
new file mode 100644
index 000000000..eaa40fb0e
--- /dev/null
+++ b/Tests/Ix/IxonV3Text.lean
@@ -0,0 +1,67 @@
+import Tests.Ix.IxonSyntax
+
+namespace Tests.IxonV3
+open Ixon.Syntax
+
+def textContractKey : Term → Option (String × Nat × Nat)
+  | .lam binders _ _ => do
+    let binder ← binders[0]?
+    if binders.size != 1 then none else
+      some ("lam", binder.contract.toBits.toNat, 0)
+  | .pi binders result _ _ => do
+    let binder ← binders[0]?
+    if binders.size != 1 then none else
+      some ("all", binder.contract.toBits.toNat, result.toBits.toNat)
+  | .arrow result _ _ _ => some ("arrow", 7, result.toBits.toNat)
+  | .letE contract _ _ _ _ _ =>
+    some ("let", contract.binder.toBits.toNat, contract.flags.toNat)
+  | _ => none
+
+def runText : IO Nat := do
+  let bytes ← IO.FS.readFile "Tests/Fixtures/ixon-v3/text.tsv"
+  let mut count := 0
+  for line in bytes.splitOn "\n" do
+    if line.isEmpty then continue
+    let [kind, input, output, source] := line.splitOn "\t"
+      | throw (IO.userError s!"invalid text fixture: {line}")
+    let some input := input.toNat? | throw (IO.userError "invalid input code")
+    let some output := output.toNat? | throw (IO.userError "invalid output code")
+    let term ← match parseTerm source with
+      | .ok term => pure term
+      | .error error => throw (IO.userError s!"{source}: {error}")
+    unless textContractKey term == some (kind, input, output) do
+      throw (IO.userError s!"text contract mismatch: {source}")
+    let printed := printTerm term
+    unless printed.replace "\n" " " == source do
+      throw (IO.userError s!"text golden mismatch: {source} / {printed}")
+    let reparsed ← match parseTerm printed with
+      | .ok term => pure term
+      | .error error => throw (IO.userError s!"{printed}: {error}")
+    unless textContractKey reparsed == textContractKey term do
+      throw (IO.userError s!"text roundtrip changed contracts: {source}")
+    count := count + 3
+  for source in [
+      "fun (!! x : A) => x", "fun (~~ x : A) => x",
+      "fun (01 x : A) => x", "fun (&1 x : A) => x",
+      "fun (~!x : A) => x", "A → !! B", "A → ~~ B",
+      "let borrow (~ x y : A) := z; x",
+      "let (!1 x y : A) := z; x"] do
+    if let .ok _ := parseTerm source then
+      throw (IO.userError s!"malformed contract accepted: {source}")
+    count := count + 1
+  for ty in ["0", "1", "10", "101 0", "1 → Prop"] do
+    let source := s!"fun [({ty})] => Prop"
+    let term ← IO.ofExcept ((parseTerm source).mapError toString)
+    let printed := printTerm term
+    unless printed == source do
+      throw (IO.userError s!"numeric unnamed binder lost disambiguation: {printed}")
+    let reparsed ← IO.ofExcept ((parseTerm printed).mapError toString)
+    unless textContractKey reparsed == some ("lam", 7, 0) do
+      throw (IO.userError "numeric unnamed binder changed its usage")
+    count := count + 1
+  let result ← LSpec.lspecIO
+    (.ofList [("ixon-text", Tests.IxonSyntax.suite)]) []
+  unless result == 0 do throw (IO.userError "text grammar regression suite failed")
+  return count
+
+end Tests.IxonV3
diff --git a/Tests/Ix/IxonV3VM.lean b/Tests/Ix/IxonV3VM.lean
new file mode 100644
index 000000000..e33a27688
--- /dev/null
+++ b/Tests/Ix/IxonV3VM.lean
@@ -0,0 +1,236 @@
+module
+public import Tests.Ix.IxonV3
+public import Tests.Aiur.Common
+public import Ix.IxVM.Toplevel
+public import Ix.IxVM.ClaimHarness
+public import Ix.Resource.Claim
+public import Tests.Ix.ResourceAddressed
+
+public section
+namespace Tests.IxonV3
+
+def codecEntrypoints := ⟦
+  pub fn ixon_expr_decode() {
+    let (idx, len) = io_get_info(0, [0]);
+    let bytes = read_byte_stream(0, idx, len);
+    let (_, rest) = get_expr(bytes);
+    assert_eq!(load(rest), ListNode.Nil, "trailing expression bytes");
+  }
+
+  pub fn ixon_const_decode() {
+    let (idx, len) = io_get_info(0, [0]);
+    let bytes = read_byte_stream(0, idx, len);
+    let (_, rest) = get_constant(bytes);
+    assert_eq!(load(rest), ListNode.Nil, "trailing constant bytes");
+  }
+
+  pub fn ixon_expr_codec() {
+    let (idx, len) = io_get_info(0, [0]);
+    let bytes = read_byte_stream(0, idx, len);
+    let (expr, rest) = get_expr(bytes);
+    assert_eq!(load(rest), ListNode.Nil, "trailing expression bytes");
+    let encoded = put_expr(load(expr), store(ListNode.Nil));
+    assert_eq!(bytes, encoded, "VM expression bytes differ");
+  }
+
+  pub fn ixon_const_codec() {
+    let (idx, len) = io_get_info(0, [0]);
+    let bytes = read_byte_stream(0, idx, len);
+    let (constant, rest) = get_constant(bytes);
+    assert_eq!(load(rest), ListNode.Nil, "trailing constant bytes");
+    let encoded = put_constant(constant, store(ListNode.Nil));
+    assert_eq!(bytes, encoded, "VM constant bytes differ");
+  }
+⟧
+
+def codecToplevel : Except Aiur.Global Aiur.Source.Toplevel := do
+  let vm ← IxVM.core.merge IxVM.byteStream
+  let vm ← vm.merge IxVM.ixon
+  let vm ← vm.merge IxVM.ixonSerialize
+  let vm ← vm.merge IxVM.ixonDeserialize
+  let vm ← vm.merge codecEntrypoints
+  return vm.prune [`ixon_expr_codec, `ixon_const_codec,
+    `ixon_expr_decode, `ixon_const_decode]
+
+def codecBuffer (bytes : ByteArray) : Aiur.IOBuffer :=
+  (default : Aiur.IOBuffer).extend 0 #[0] (bytes.data.map .ofUInt8)
+
+/-- Check acceptance, empty output, and an unchanged I/O buffer on each interpreter.
+Production claims also run through the generated Rust VM with query-count parity. -/
+def checkVM (env : AiurTestEnv) (label : String) (fnName : Lean.Name)
+    (input : Array Aiur.G) (buffer : Aiur.IOBuffer) (accept : Bool)
+    (generated : Bool := false) : IO Nat := do
+  let some index := env.compiled.getFuncIdx fnName
+    | throw <| IO.userError s!"{label}: missing VM entrypoint {fnName}"
+  let executed := env.compiled.bytecode.execute index input buffer
+  match executed with
+  | .ok (out, io, _) =>
+    unless accept && out.isEmpty && io == buffer do
+      throw <| IO.userError s!"{label}: VM unexpectedly accepted or changed output"
+  | .error e =>
+    if accept then throw <| IO.userError s!"{label}: VM execution failed: {e}"
+  if generated then
+    match env.compiled.bytecode.executeIxVM index input buffer with
+    | .ok (out, io, counts) =>
+      let .ok (expectedOut, expectedIO, expectedCounts) := executed
+        | throw <| IO.userError s!"{label}: generated VM accepted a rejected input"
+      unless accept && out == expectedOut && io == expectedIO &&
+          counts.size == expectedCounts.size &&
+          (counts.zip expectedCounts).all (fun (actual, expected) =>
+            actual.uniqueRows == expected.uniqueRows && actual.totalHits == expected.totalHits) do
+        throw <| IO.userError s!"{label}: generated VM output or query counts differ"
+    | .error e =>
+      if accept then throw <| IO.userError s!"{label}: generated VM execution failed: {e}"
+  let name := Aiur.Global.mk fnName
+  let some (.function function) := env.decls.getByKey name
+    | throw <| IO.userError s!"{label}: missing source entrypoint {fnName}"
+  let inputs := Aiur.unflattenInputs env.decls input (function.inputs.map (·.2))
+  let (interpreted, state) := Aiur.runFunction env.decls name inputs buffer
+  match interpreted with
+  | .ok value =>
+    let flattened := Aiur.flattenValue env.decls (fun g => env.compiled.getFuncIdx g.toName) value
+    unless accept && flattened.isEmpty && state.ioBuffer == buffer do
+      throw <| IO.userError s!"{label}: source interpretation unexpectedly accepted or changed output"
+  | .error e =>
+    if accept then throw <| IO.userError s!"{label}: source interpretation failed: {e}"
+  return if generated then 3 else 2
+
+def checkVMBytes (env : AiurTestEnv) (name : String) (bytes : ByteArray)
+    (accept : Bool) (fnName : Lean.Name := `ixon_expr_codec) : IO Nat :=
+  checkVM env name fnName #[] (codecBuffer bytes) accept
+
+def checkVMEncoding (env : AiurTestEnv) (name : String) (bytes : ByteArray)
+    (fnName : Lean.Name := `ixon_expr_codec) : IO Nat := do
+  let mut checks ← checkVMBytes env name bytes true fnName
+  checks := checks + (← checkVMBytes env s!"{name}-trailing" (bytes.push 0) false fnName)
+  for n in [:bytes.size] do
+    checks := checks + (← checkVMBytes env s!"{name}-truncated-{n}" (bytes.extract 0 n) false fnName)
+  return checks
+
+def checkVMProof (env : AiurTestEnv) (fnName : Lean.Name)
+    (input : Array Aiur.G) (buffer : Aiur.IOBuffer) : IO Unit := do
+  let index := env.compiled.getFuncIdx fnName |>.get!
+  let (claim, proof, _) ← IO.ofExcept (env.aiurSystem.prove index input buffer)
+  IO.ofExcept (env.aiurSystem.verify claim (Aiur.Proof.ofBytes proof.toBytes))
+
+/-- Every counted decoding path accepts one complete element and rejects a
+short stream when the count is two or the largest canonical UInt64. Each
+truncated stream supplies one element, then ends. The decode-only entrypoints
+ensure rejection happens before reserialization. -/
+def runCountTruncations (env : AiurTestEnv) : IO Nat := do
+  let mut checks := 0
+  for count in [1, 2, (2 ^ 64 - 1 : Nat)] do
+    let large := count > 2
+    let accept := count == 1
+    let suffix : Array UInt8 := if large then Array.replicate 8 0xff else #[]
+    let tag0 : ByteArray := .mk ((if large then #[0x87] else #[count.toUInt8]) ++ suffix)
+    let tag4 (flag : UInt8) : ByteArray :=
+      .mk (#[flag * 16 + (if large then 15 else count.toUInt8)] ++ suffix)
+    let finish (bytes tail : ByteArray) := if accept then bytes ++ tail else bytes
+    let countLabel := if large then "max-u64" else toString count
+    for (label, bytes) in [
+        ("ref-universes", tag4 2 ++ .mk #[0, 0]),
+        ("rec-universes", tag4 3 ++ .mk #[0, 0]),
+        ("app-arguments", tag4 7 ++ .mk #[0x10, 0x10]),
+        ("lambda-binders", finish (tag4 8 ++ .mk #[0x07, 0x00]) (.mk #[0x10])),
+        ("forall-binders", finish (tag4 9 ++ .mk #[0x17, 0x00]) (.mk #[0x10]))] do
+      checks := checks + (← checkVMBytes env s!"{label}-{countLabel}"
+        bytes accept `ixon_expr_decode)
+    let axiomPrefix : ByteArray := .mk #[0xd2, 0, 0, 0]
+    for (label, bytes) in [
+        ("sharing", finish (axiomPrefix ++ tag0 ++ .mk #[0x10]) (.mk #[0, 0])),
+        ("references", finish (axiomPrefix ++ .mk #[0] ++ tag0 ++
+          .mk (Array.replicate 32 0)) (.mk #[0])),
+        ("universes", axiomPrefix ++ .mk #[0, 0] ++ tag0 ++ .mk #[0]),
+        ("recursor-rules", finish (.mk #[0xd1, 0, 0, 0, 0, 0, 0, 0] ++
+          tag0 ++ .mk #[0, 0x10]) (.mk #[0, 0, 0])),
+        ("constructors", finish (.mk #[0xc1, 1, 0, 0, 0, 0, 0] ++
+          tag0 ++ .mk #[0, 0, 0, 0, 0, 0]) (.mk #[0, 0, 0])),
+        ("mutual-members", finish (tag4 12 ++ .mk #[0, 0x06, 0x05, 0x00, 0x10])
+          (.mk #[0, 0, 0]))] do
+      checks := checks + (← checkVMBytes env s!"{label}-{countLabel}"
+        bytes accept `ixon_const_decode)
+  return checks
+
+def replaceClaimBytes (witness : IxVM.ClaimHarness.ClaimWitness) (bytes : ByteArray) :
+    IxVM.ClaimHarness.ClaimWitness :=
+  let key := IxVM.ClaimHarness.packedDigestKey (Address.blake3 bytes)
+  { witness with
+    input := key
+    inputIOBuffer := witness.inputIOBuffer.extend 0 key (bytes.data.map .ofUInt8) }
+
+def checkVMClaim (env : AiurTestEnv) (label : String)
+    (witness : IxVM.ClaimHarness.ClaimWitness) (accept : Bool) : IO Nat :=
+  checkVM env label witness.funcName witness.input witness.inputIOBuffer accept (generated := true)
+
+def runVMClaims : IO Nat := do
+  let vm ← IO.ofExcept (AiurTestEnv.build IxVM.ixVM)
+  let (base, unit) := Tests.ResourceAddressed.unitEnv
+  let constant := Tests.ResourceAddressed.identity unit
+  let (env, validTarget) := Tests.ResourceAddressed.store base constant
+  let env := { env with anonHints := env.anonHints.insert validTarget .opaque }
+  let some tree := IxVM.ClaimHarness.envCanonicalTree env
+    | throw <| IO.userError "VM claim fixture has no tree"
+  let trees := ({} : Std.HashMap Address Ix.AssumptionTree).insert tree.root tree
+  let mut checks := 0
+  let revealedType := Address.blake3 (Ixon.runPut (Ixon.putExpr
+    (.all Tests.ResourceAddressed.linearLocal .localShared (.ref 0 #[]) (.ref 0 #[]))))
+  for (name, claim) in [
+      ("check", Ix.Claim.check validTarget none),
+      ("check-env", .checkEnv tree.root none),
+      ("reveal", .reveal validTarget (.defn none none none (some revealedType) none)),
+      ("contains", .contains tree.root validTarget)] do
+    let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env claim trees)
+    checks := checks + (← checkVMClaim vm name witness true)
+    let bytes := Ix.Claim.ser claim
+    for (mutation, bad) in [
+        ("trailing", bytes.push 0), ("legacy-version", bytes.set! 1 2),
+        ("wrong-validator", bytes.set! 2 255), ("truncated", bytes.extract 0 (bytes.size - 1))] do
+      checks := checks + (← checkVMClaim vm s!"{name}-{mutation}"
+        (replaceClaimBytes witness bad) false)
+  -- Erased typing deliberately accepts a resource-invalid body. The
+  -- validator byte keeps that fact separate from resource admission.
+  let (escaping, escapingTarget) := Tests.ResourceAddressed.store base
+    (Tests.ResourceAddressed.identity unit Tests.ResourceAddressed.linearLocal .shared)
+  let escaping := { escaping with anonHints := escaping.anonHints.insert escapingTarget .opaque }
+  let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness escaping (.check escapingTarget none))
+  checks := checks + (← checkVMClaim vm "explicit erased typing" witness true)
+  unless (Ix.Resource.validate escaping {}).toOption.isNone do
+    throw <| IO.userError "escaping fixture passed native resource validation"
+  -- Resource claims have a native validator, and must fail explicitly at
+  -- the circuit boundary rather than accepting a host validation result.
+  let profile : Ix.Resource.Profile := {}
+  let claim ← IO.ofExcept (Ix.Resource.makeClaim env profile)
+  let profileAddr ← IO.ofExcept profile.address
+  let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env claim trees
+    (({} : Std.HashMap Address ByteArray).insert profileAddr profile.bytes))
+  checks := checks + (← checkVMClaim vm "unsupported circuit resource validator" witness false)
+  let checkWitness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env (.check validTarget none))
+  checkVMProof vm checkWitness.funcName checkWitness.input checkWitness.inputIOBuffer
+  return checks + 1
+
+def runVM (cases : List ExprCase) : IO Nat := do
+  let env ← IO.ofExcept (AiurTestEnv.build codecToplevel)
+  let mut checks := 0
+  for test in cases do
+    checks := checks + (← checkVMEncoding env test.name test.bytes)
+  for (name, bytes) in rejectedExprCases do
+    checks := checks + (← checkVMBytes env name bytes false)
+  checks := checks + (← runCountTruncations env)
+  -- Independently authored declaration bytes cover the six unchanged headers.
+  for (name, hex) in [
+      ("definition", "d006050010000000"),
+      ("recursor", "d101050102030400010310000000"),
+      ("axiom", "d2010500000000"),
+      ("quotient", "d3020500000000"),
+      ("mutual", "c101000502030001010501020300000000")] do
+    let some bytes := bytesOfHex hex
+      | throw <| IO.userError s!"invalid declaration fixture hex: {name}"
+    checks := checks + (← checkVMEncoding env name bytes `ixon_const_codec)
+  -- Exercise the proof pipeline for an explicit scoped-borrow representation.
+  let bytes := ByteArray.mk #[0xA2, 0x0e, 0x00, 0x41, 0x02, 0x11, 0x10]
+  checkVMProof env `ixon_expr_codec #[] (codecBuffer bytes)
+  -- Execute and prove the actual production claim boundary as well.
+  return checks + 2 + (← runVMClaims)
+
+end Tests.IxonV3
diff --git a/Tests/Ix/Resource.lean b/Tests/Ix/Resource.lean
new file mode 100644
index 000000000..5f49a5994
--- /dev/null
+++ b/Tests/Ix/Resource.lean
@@ -0,0 +1,312 @@
+module
+
+public import Ix.Resource.Check
+
+public section
+
+namespace Tests.Resource
+
+open Ixon Ix.Resource
+
+abbrev E := Ixon.Expr
+
+def natTy : E := .ref 0 #[]
+def pairTy : E := .ref 7 #[]
+def zero : E := .nat 0
+def b (uses : Uses) (value : ValueContract := .shared) : BinderContract := ⟨uses, value⟩
+def arr (input : BinderContract) (result : ValueContract := .shared)
+    (domain : E := natTy) (codomain : E := natTy) : E := .all input result domain codomain
+def lam (input : BinderContract) (body : E) (domain : E := natTy) : E := .lam input domain body
+def v (n : UInt64) : E := .var n
+def ref (n : UInt64) : E := .ref n #[]
+def call (n : UInt64) (arg : E) : E := .app (ref n) arg
+def bind (contract : BinderContract) (value body : E) (type : E := natTy) : E :=
+  .letE { nonDep := false, binder := contract } type value body
+def borrow (owner body : E) (uses : Uses := .many) (type : E := natTy) : E :=
+  .letE (.borrow false uses) type owner body
+
+def choiceType (result : ValueContract) : E :=
+  arr (b .linear) .shared natTy
+    (arr (b .affine result) .shared natTy (arr (b .affine result) result))
+
+/-- Test-only explicit assumptions. Production admission must bind their
+addresses and the special selection behavior in its checker profile. -/
+def program : Program := {
+  declarations := #[
+    { type := .sort 0, kind := .typeConstructor },                            -- 0 Nat
+    { type := arr (b .many .localShared), kind := .assumption },              -- 1 observe
+    { type := arr (b .linear .localShared) .localShared,
+      body := some (lam (b .linear .localShared) (v 0)) },                    -- 2 local id
+    { type := arr (b .linear .unique) .unique,
+      body := some (lam (b .linear .unique) (v 0)) },                         -- 3 unique id
+    { type := arr (b .erased), kind := .assumption },                        -- 4 erased input
+    { type := arr (b .many), kind := .assumption },                          -- 5 many input
+    { type := choiceType .shared, kind := .assumption },                     -- 6 choice
+    { type := .sort 0, kind := .typeConstructor },                            -- 7 Pair
+    { type := arr (b .linear .localShared) .localShared natTy pairTy,
+      kind := .assumption },                                               -- 8 retain in pair
+    { type := choiceType .localShared, kind := .assumption },                -- 9 local choice
+    { type := choiceType .unique, kind := .assumption }                      -- 10 unique choice
+  ]
+  fields := #[
+    { typeRef := 7, index := 0, type := natTy, contract := .unique },
+    { typeRef := 7, index := 1, type := arr (b .many), contract := .unique },
+    { typeRef := 7, index := 2, type := arr (b .many), contract := .shared }
+  ]
+  natType := some natTy
+  stringType := some natTy
+  sharing := #[v 0, ref 6]
+  shareableTypes := #[0, 7]
+  choices := #[6, 9, 10]
+}
+
+def choose (which : UInt64) (left right : E) : E :=
+  .app (.app (call which zero) left) right
+
+def runCase (type value : E) (limits : Limits := {}) : Except Error Unit :=
+  let p := { program with declarations := program.declarations.push { type, body := some value } }
+  checkDefinition p program.declarations.size limits
+
+def errorCode : Error → String
+  | .budget => "budget"
+  | .unbound _ => "unbound"
+  | .badReference _ => "reference"
+  | .unresolvedSharing _ => "sharing"
+  | .unsupported _ => "unsupported"
+  | .typeMismatch => "type"
+  | .binderMismatch => "binder"
+  | .usage .. => "usage"
+  | .moved _ => "moved"
+  | .sharedToUnique => "ownership"
+  | .activeLoan _ => "loan"
+  | .escape .. => "escape"
+  | .unrestrictedEscape _ => "unrestricted"
+  | .nonduplicable => "capture"
+  | .invalidBorrow => "borrow"
+  | .invalidPlace => "place"
+  | .invalidScope => "scope"
+
+structure Case where
+  name : String
+  type : E
+  value : E
+  expected : String := "ok"
+
+def closureType (result : ValueContract := .shared) : E := arr (b .many) result
+
+def scopedRead (body : E) : E :=
+  bind (b .affine) (borrow (v 0) body) (v 1)
+
+def cases : Array Case := #[
+  -- Usage
+  ⟨"ordinary identity", arr (b .many), lam (b .many) (v 0), "ok"⟩,
+  ⟨"linear identity", arr (b .linear), lam (b .linear) (v 0), "ok"⟩,
+  ⟨"unused erased", arr (b .erased), lam (b .erased) zero, "ok"⟩,
+  ⟨"erased argument has zero demand", arr (b .erased),
+    lam (b .erased) (call 4 (v 0)), "ok"⟩,
+  ⟨"unused affine", arr (b .affine), lam (b .affine) zero, "ok"⟩,
+  ⟨"missing linear consumption", arr (b .linear), lam (b .linear) zero, "usage"⟩,
+  ⟨"runtime erased variable", arr (b .erased), lam (b .erased) (v 0), "usage"⟩,
+  ⟨"many invocation scales demand", arr (b .affine), lam (b .affine) (call 5 (v 0)), "usage"⟩,
+  ⟨"many permits repeated demand", arr (b .many), lam (b .many) (call 5 (v 0)), "ok"⟩,
+  ⟨"linear ordinary let", arr (b .linear),
+    lam (b .linear) (bind (b .linear) (v 0) (v 0)), "ok"⟩,
+  ⟨"erased let initializer", arr (b .linear),
+    lam (b .linear) (bind (b .erased) (v 0) (v 1)), "ok"⟩,
+  ⟨"duplicate affine through let", arr (b .affine),
+    lam (b .affine) (bind (b .affine) (v 0) (v 1)), "usage"⟩,
+  ⟨"fresh inner linear binder under many demand", arr (b .many),
+    lam (b .many) (call 5 (bind (b .linear) (v 0) (v 0))), "ok"⟩,
+  ⟨"type formation has zero runtime demand", arr (b .erased) .shared (.sort 0) (.sort 0),
+    lam (b .erased) (v 0) (.sort 0), "ok"⟩,
+  ⟨"type use cannot discharge linear runtime obligation", arr (b .linear) .shared (.sort 0) (.sort 0),
+    lam (b .linear) (v 0) (.sort 0), "usage"⟩,
+
+  -- Ownership transfers
+  ⟨"linear unique transfer", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (v 0), "ok"⟩,
+  ⟨"shared cannot become unique", arr (b .linear) .unique,
+    lam (b .linear) (v 0), "ownership"⟩,
+  ⟨"unique cannot transfer twice despite many", arr (b .many .unique) .unique,
+    lam (b .many .unique) (bind (b .linear .unique) (v 0)
+      (bind (b .linear .unique) (v 1) (v 0))), "moved"⟩,
+  ⟨"permanent sharing relinquishes unique", arr (b .many .unique) .unique,
+    lam (b .many .unique) (bind (b .affine) (v 0) (v 1)), "ownership"⟩,
+
+  -- Locality
+  ⟨"local input local output", arr (b .linear .localShared) .localShared,
+    lam (b .linear .localShared) (v 0), "ok"⟩,
+  ⟨"local unique input local unique output", arr (b .linear .localUnique) .localUnique,
+    lam (b .linear .localUnique) (v 0), "ok"⟩,
+  ⟨"local input cannot escape", arr (b .linear .localShared),
+    lam (b .linear .localShared) (v 0), "unrestricted"⟩,
+  ⟨"local helper result can be forwarded", arr (b .linear .localShared) .localShared,
+    lam (b .linear .localShared) (call 2 (v 0)), "ok"⟩,
+  ⟨"inner local let cannot escape as local", arr (b .linear) .localShared,
+    lam (b .linear) (bind (b .linear .localShared) (v 0) (v 0)), "escape"⟩,
+
+  -- Shared loans
+  ⟨"borrow ends before owner transfer", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (scopedRead (call 1 (v 0))), "ok"⟩,
+  ⟨"unique access during loan", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (borrow (v 0) (v 1)), "loan"⟩,
+  ⟨"loan view cannot escape", arr (b .many .unique) .localShared,
+    lam (b .many .unique) (borrow (v 0) (v 0)), "escape"⟩,
+  ⟨"loan end does not restore permanently shared owner", arr (b .many .unique) .unique,
+    lam (b .many .unique) (scopedRead (v 1)), "ownership"⟩,
+  ⟨"nested shared reborrow", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (scopedRead (borrow (v 0) (call 1 (v 0)))), "ok"⟩,
+  ⟨"borrow requires owner place", arr (b .many .unique),
+    lam (b .many .unique) (borrow (call 3 (v 0)) zero), "place"⟩,
+  ⟨"borrow cannot manufacture unique view", arr (b .many .unique),
+    lam (b .many .unique) (.letE {
+      nonDep := false
+      kind := .borrowShared
+      binder := b .many .localUnique } natTy (v 0) zero), "borrow"⟩,
+  ⟨"moved owner cannot be borrowed", arr (b .many .unique) .unique,
+    lam (b .many .unique) (bind (b .linear .unique) (v 0)
+      (borrow (v 1) (v 1))), "moved"⟩,
+  ⟨"projected loan suspends whole owner", arr (b .linear .unique) .unique pairTy pairTy,
+    lam (b .linear .unique) (borrow (.prj 7 0 (v 0)) (v 1)) pairTy, "loan"⟩,
+  ⟨"projected loan ends before owner transfer", arr (b .linear .unique) .unique pairTy pairTy,
+    lam (b .linear .unique)
+      (bind (b .affine) (borrow (.prj 7 0 (v 0)) (call 1 (v 0))) (v 1)) pairTy, "ok"⟩,
+  ⟨"discarding borrow before narrowing fresh result", arr (b .many .unique) .localShared,
+    lam (b .many .unique) (borrow (v 0) (call 1 (v 0))), "ok"⟩,
+  ⟨"erased owner cannot be restored through a borrow", arr (b .erased .unique),
+    lam (b .erased .unique) (borrow (v 0) (call 1 (v 0))), "unsupported"⟩,
+  ⟨"erased view cannot be restored through a reborrow", arr (b .many .unique),
+    lam (b .many .unique) (borrow (v 0) (borrow (v 0) (call 1 (v 0))) .erased), "unsupported"⟩,
+
+  -- Captures and projections
+  ⟨"shared closure cannot hide affine capture", arr (b .affine) .shared natTy (closureType .shared),
+    lam (b .affine) (lam (b .many) (v 1)), "capture"⟩,
+  ⟨"unique closure retains finite capture", arr (b .linear) .unique natTy (closureType .shared),
+    lam (b .linear) (lam (b .many) (v 1)), "ok"⟩,
+  ⟨"local closure may retain local input", arr (b .many .localShared) .localShared natTy (closureType .localShared),
+    lam (b .many .localShared) (lam (b .many) (v 1)), "ok"⟩,
+  ⟨"closure cannot hide local escape", arr (b .many .localShared) .shared natTy (closureType .localShared),
+    lam (b .many .localShared) (lam (b .many) (v 1)), "unrestricted"⟩,
+  ⟨"aggregate cannot hide local escape", arr (b .linear .localShared) .shared natTy pairTy,
+    lam (b .linear .localShared) (call 8 (v 0)), "unrestricted"⟩,
+  ⟨"aggregate retains caller locality", arr (b .linear .localShared) .localShared natTy pairTy,
+    lam (b .linear .localShared) (call 8 (v 0)), "ok"⟩,
+  ⟨"shared aggregate cannot expose reusable unique closure", arr (b .linear) .shared pairTy (closureType .shared),
+    lam (b .linear) (.prj 7 1 (v 0)) pairTy, "capture"⟩,
+  ⟨"unique aggregate transfers unique closure field", arr (b .linear .unique) .unique pairTy (closureType .shared),
+    lam (b .linear .unique) (.prj 7 1 (v 0)) pairTy, "ok"⟩,
+  ⟨"shared field retains its reusable function contract", arr (b .linear) .shared pairTy (closureType .shared),
+    lam (b .linear) (.prj 7 2 (v 0)) pairTy, "ok"⟩,
+  ⟨"projected borrow cannot launder unique closure", arr (b .many) .shared pairTy natTy,
+    lam (b .many) (borrow (.prj 7 1 (v 0)) zero .many (closureType .shared)) pairTy, "capture"⟩,
+  ⟨"capturing owner transfers it even when closure only borrows", arr (b .linear .unique) .unique natTy (closureType .shared),
+    lam (b .linear .unique) (lam (b .many) (borrow (v 1) (call 1 (v 0)))), "ok"⟩,
+  ⟨"reborrowing closure captures the view without moving its root", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (scopedRead
+      (bind (b .linear .localShared)
+        (lam (b .many) (borrow (v 1) (call 1 (v 0))))
+        (.app (v 0) zero) (closureType .shared))), "ok"⟩,
+
+  -- Branches and selection
+  ⟨"linear use in both alternatives", arr (b .linear),
+    lam (b .linear) (choose 6 (v 0) (v 0)), "ok"⟩,
+  ⟨"linear missing in one alternative", arr (b .linear),
+    lam (b .linear) (choose 6 (v 0) zero), "usage"⟩,
+  ⟨"affine use in one alternative", arr (b .affine),
+    lam (b .affine) (choose 6 (v 0) zero), "ok"⟩,
+  ⟨"unique move in each alternative", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (choose 10 (v 0) (v 0)), "ok"⟩,
+  ⟨"alternative move prevents later use", arr (b .many .unique) .unique,
+    lam (b .many .unique) (bind (b .affine .unique) (choose 10 (v 0) zero) (v 1)), "moved"⟩,
+  ⟨"partial selection is not an ordinary function", arr (b .many),
+    lam (b .many) (call 6 (v 0)), "unsupported"⟩,
+  ⟨"selection cannot bypass its rule through a callback", arr (b .many) .shared natTy (choiceType .shared),
+    lam (b .many) (ref 6), "unsupported"⟩,
+  ⟨"branch analysis follows a shared application head", arr (b .linear),
+    lam (b .linear) (.app (.app (.app (.share 1) zero) (v 0)) (v 0)), "ok"⟩,
+
+  -- Interfaces and sharing
+  ⟨"unregistered projection has no optimistic rule", arr (b .many .unique),
+    lam (b .many .unique) (.prj 0 0 (v 0)), "unsupported"⟩,
+  ⟨"sharing checked in live binder context", arr (b .linear),
+    lam (b .linear) (.share 0), "ok"⟩,
+  ⟨"sharing cannot cache away erased restriction", arr (b .erased),
+    lam (b .erased) (.share 0), "usage"⟩,
+  ⟨"lambda and interface input must agree", arr (b .linear),
+    lam (b .many) (v 0), "binder"⟩,
+  ⟨"erased higher order argument still checks its contracts", arr (b .erased) .shared (arr (b .linear)) natTy,
+    lam (b .erased) (.app (lam (b .erased) zero (arr (b .many))) (v 0)) (arr (b .linear)), "type"⟩,
+  ⟨"erased higher order argument with matching interface", arr (b .erased) .shared (arr (b .many)) natTy,
+    lam (b .erased) (.app (lam (b .erased) zero (arr (b .many))) (v 0)) (arr (b .many)), "ok"⟩
+]
+
+def higherOrderCases : Array Case := Id.run do
+  let callback := arr (b .linear .localShared)
+  let type := arr (b .many .localShared) .localShared callback
+    (arr (b .linear .localShared))
+  let value := lam (b .many .localShared)
+    (lam (b .linear .localShared) (.app (v 1) (v 0))) callback
+  let recursiveType := arr (b .many) .shared natTy
+    (arr (b .linear .localShared) .localShared)
+  let recursiveBody := lam (b .many) (lam (b .linear .localShared)
+    (choose 9 (v 0) (.app (call 11 (v 1)) (v 0))))
+  let mismatched := arr (b .many) .shared (arr (b .linear .localShared))
+    (arr (b .many) .shared (arr (b .many)) natTy)
+  let mismatchBody := lam (b .many)
+    (lam (b .many) (bind (b .linear) (v 1) zero (arr (b .many))))
+    (arr (b .linear .localShared))
+  return #[
+    ⟨"higher order local callback and argument", type, value, "ok"⟩,
+    ⟨"recursive contract retains resource across alternatives", recursiveType, recursiveBody, "ok"⟩,
+    ⟨"higher order contract mismatch", mismatched, mismatchBody, "type"⟩
+  ]
+
+def allCases : Array Case := cases ++ higherOrderCases
+
+def runFixtureCases : IO Nat := do
+  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/resource.tsv"
+  let lines := file.splitOn "\n"
+  for test in allCases do
+    let actual := runCase test.type test.value
+    let code := match actual with | .ok _ => "ok" | .error e => errorCode e
+    unless code == test.expected do
+      throw <| IO.userError s!"resource: {test.name}: expected {test.expected}, got {repr actual}"
+    let line := s!"{test.name}\t{test.expected}\t{hexOfBytes (runPut (putExpr test.type))}\t{hexOfBytes (runPut (putExpr test.value))}"
+    unless lines.contains line do
+      throw <| IO.userError s!"resource fixture bytes differ: {test.name}"
+  return allCases.size
+
+def runContractMatrix : IO Nat := do
+  let mut checks := 0
+  for code in [0:16] do
+    let some input := BinderContract.ofBits? code.toUInt8
+      | throw <| IO.userError "invalid generated input code"
+    for resultCode in [0:4] do
+      let some result := ValueContract.ofBits? resultCode.toUInt8
+        | throw <| IO.userError "invalid generated result code"
+      let body := if input.uses == .erased then zero else v 0
+      let allowed := input.uses == .erased ||
+        ((input.value.owned == .unique || result.owned == .shared) &&
+         (input.value.locality == .unrestricted || result.locality == .local))
+      unless (runCase (arr input result) (lam input body)).toOption.isSome == allowed do
+        throw <| IO.userError s!"resource contract matrix differs at {code}/{resultCode}"
+      checks := checks + 1
+  return checks
+
+/-- Budget exhaustion is an error, including cycles through open sharing. -/
+def checkSharingBudget : IO Unit := do
+  let cyclic := { program with sharing := #[.share 0] }
+  let action := analyze 20 { program := cyclic } (.share 0) none 0 .linear
+  match action.run {} with
+  | .error .budget _ => pure ()
+  | _ => throw <| IO.userError "cyclic sharing did not exhaust the bound"
+
+def run : IO Unit := do
+  let fixtures ← runFixtureCases
+  let matrix ← runContractMatrix
+  checkSharingBudget
+  IO.println s!"Resource checker: {fixtures + matrix + 1} positive/negative and mode checks passed"
+
+end Tests.Resource
+
+end
diff --git a/Tests/Ix/ResourceAddressed.lean b/Tests/Ix/ResourceAddressed.lean
new file mode 100644
index 000000000..d0d6fe569
--- /dev/null
+++ b/Tests/Ix/ResourceAddressed.lean
@@ -0,0 +1,159 @@
+module
+
+public import Ix.Resource.Addressed
+
+public section
+
+namespace Tests.ResourceAddressed
+
+open Ixon Ix.Resource
+
+abbrev E := Ixon.Expr
+
+def store (env : Ixon.Env) (c : Constant) : Ixon.Env × Address :=
+  let address := Addressed.commit c
+  (env.storeConst address c, address)
+
+def unitBlock : Constant := {
+  info := .muts #[.indc ⟨false, 0, 0, 0, .sort 0,
+    #[⟨false, 0, 0, 0, 0, .recur 0 #[]⟩]⟩]
+  sharing := #[], refs := #[], univs := #[.zero] }
+
+def unitEnv : Ixon.Env × Address := Id.run do
+  let (env, block) := store {} unitBlock
+  let (env, type) := store env (Addressed.wrapper (.iPrj ⟨0, block⟩))
+  let (env, _) := store env (Addressed.constructorWrapper block 0 0)
+  return (env, type)
+
+def linearLocal : Ixon.BinderContract := ⟨.linear, .localShared⟩
+
+def identity (unit : Address) (input : Ixon.BinderContract := linearLocal)
+    (result : ValueContract := .localShared) : Constant := {
+  info := .defn ⟨.defn, .safe, 0,
+    .all input result (.ref 0 #[]) (.ref 0 #[]),
+    .lam input (.ref 0 #[]) (.share 0)⟩
+  sharing := #[.var 0], refs := #[unit], univs := #[] }
+
+def fixtures : Array (String × Constant) := Id.run do
+  let (_, unit) := unitEnv
+  return #[ ("unit", unitBlock), ("identity", identity unit),
+    ("identity_unique", identity unit ⟨.linear, .unique⟩ .unique) ]
+
+def check (label : String) (result : Except String α) (accept : Bool) : IO Unit := do
+  unless result.toOption.isSome == accept do
+    let diagnostic := match result with | .error e => e | .ok _ => "accepted"
+    throw <| IO.userError s!"addressed resource {label}: expected {accept}, got {diagnostic}"
+
+def get (label : String) (result : Except String α) : IO α :=
+  match result with
+  | .ok value => pure value
+  | .error e => throw <| IO.userError s!"addressed resource {label}: {e}"
+
+def run : IO Unit := do
+  let (base, unit) := unitEnv
+  let profile : Profile := { natType := some unit, shareableTypes := #[unit] }
+  let fixture ← IO.FS.readFile "Tests/Fixtures/ixon-v3/addressed.tsv"
+  let lines := fixture.splitOn "\n"
+  for (label, constant) in fixtures do
+    let line := s!"{label}\t{Addressed.commit constant}\t{hexOfBytes (serConstant constant)}"
+    unless lines.contains line do throw <| IO.userError s!"addressed fixture differs: {label}"
+  let profileAddress ← get "profile address" profile.address
+  unless lines.contains s!"profile\t{profileAddress}\t{hexOfBytes profile.bytes}" do
+    throw <| IO.userError "addressed profile fixture differs"
+  let decoded ← get "profile roundtrip" (Profile.ofBytes profile.bytes)
+  unless decoded.bytes == profile.bytes do throw <| IO.userError "profile roundtrip differs"
+  for length in [:profile.bytes.size] do
+    check "truncated profile" (Profile.ofBytes (profile.bytes.extract 0 length)) false
+  check "profile trailing bytes" (Profile.ofBytes (profile.bytes.push 0)) false
+  check "wrong validator" (Profile.ofBytes (profile.bytes.set! 0 0)) false
+  let (env, id) := store base (identity unit)
+  let prepared ← get "valid identity" (Addressed.checkResources env profile)
+  unless prepared.program.declarations.size == 3 && prepared.program.groups.size == 1 do
+    throw <| IO.userError "addressed resource: nominal block flattening"
+  check "unrestricted result cannot hide local input"
+    (Addressed.checkResources (store base (identity unit linearLocal .shared)).1 profile) false
+  check "profile bytes canonical" ({ profile with shareableTypes := #[unit, unit] }.address) false
+  check "selection assumption required" ({ profile with choices := #[id] }.address) false
+  check "literal nominal kind" (Addressed.prepare env { profile with natType := some id }) false
+  check "missing typed dependency" (Addressed.prepare (store {} (identity unit)).1 profile) false
+  let bogus := Address.blake3 ⟨#[9]⟩
+  check "raw hash mismatch" (Addressed.prepare (env.storeConst bogus (identity unit)) profile) false
+  let raw := (serConstant (identity unit)).push 0
+  let trailing : Ixon.Env := { base with
+    consts := base.consts.insert (Address.blake3 raw) (LazyConstant.ofSlice raw 0 raw.size) }
+  check "whole-object trailing bytes" (Addressed.prepare trailing profile) false
+  let honest := LazyConstant.ofConstant (identity unit)
+  let forged := { honest with cache := some unitBlock }
+  let resolved ← get "ignore forged materialized cache"
+    (Addressed.prepare { env with consts := env.consts.insert id forged } profile)
+  unless resolved.addresses == prepared.addresses do
+    throw <| IO.userError "addressed adapter trusted a materialized cache"
+  let orphan := Addressed.wrapper (.iPrj ⟨99, Addressed.commit unitBlock⟩)
+  check "out-of-range projection" (Addressed.prepare (store env orphan).1 profile) false
+  let cprj := Addressed.commit (Addressed.constructorWrapper (Addressed.commit unitBlock) 0 0)
+  check "missing constructor wrapper"
+    (Addressed.prepare { env with consts := env.consts.erase cprj } profile) false
+  let wrongWrapper := { Addressed.wrapper (.iPrj ⟨0, Addressed.commit unitBlock⟩) with univs := #[.zero] }
+  check "nonempty projection tables" (Addressed.prepare (store env wrongWrapper).1 profile) false
+  let extern : Constant := {
+    info := .axio ⟨false, 0, .all linearLocal .shared (.ref 0 #[]) (.ref 0 #[])⟩
+    sharing := #[], refs := #[unit], univs := #[] }
+  let (externalEnv, external) := store base extern
+  check "unadmitted external interface" (Addressed.checkResources externalEnv profile) false
+  check "explicit external assumption"
+    (Addressed.checkResources externalEnv { profile with assumptions := #[external] }) true
+  let mut blobEnv := base
+  let mut literalDecls := #[]
+  for byte in #[0, 1] do
+    let (next, blob) := blobEnv.storeBlob ⟨#[byte]⟩
+    let c : Constant := {
+      info := .defn ⟨.defn, .safe, 0, .ref 0 #[], .nat 1⟩
+      sharing := #[], refs := #[unit, blob], univs := #[] }
+    let (next, address) := store next c
+    blobEnv := next
+    literalDecls := literalDecls.push address
+  let resolved ← get "literal identities" (Addressed.prepare blobEnv profile)
+  let literalBodies := resolved.program.declarations.filterMap (·.body)
+  unless literalBodies.size == 2 && literalBodies[0]! != literalBodies[1]! do
+    throw <| IO.userError "literal identities collided across local reference tables"
+  let badBlob := { blobEnv with blobs := blobEnv.blobs.insert bogus ⟨#[0]⟩ }
+  check "blob integrity" (Addressed.prepare badBlob profile) false
+  let recursiveType := Ixon.Expr.all ⟨.linear, .unique⟩ .unique (.ref 0 #[]) (.ref 0 #[])
+  let recursive : Constant := {
+    info := .muts #[
+      .defn ⟨.defn, .safe, 0, recursiveType,
+        .lam ⟨.linear, .unique⟩ (.ref 0 #[]) (.app (.recur 1 #[]) (.var 0))⟩,
+      .defn ⟨.defn, .safe, 0, recursiveType,
+        .lam ⟨.linear, .unique⟩ (.ref 0 #[]) (.app (.recur 0 #[]) (.var 0))⟩]
+    sharing := #[], refs := #[unit], univs := #[] }
+  let (recEnv, block) := store base recursive
+  let (recEnv, _) := store recEnv (Addressed.wrapper (.dPrj ⟨0, block⟩))
+  let (recEnv, _) := store recEnv (Addressed.wrapper (.dPrj ⟨1, block⟩))
+  check "mutual recursive interface checking" (Addressed.checkResources recEnv profile) true
+  let recursor : Constant := {
+    info := .recr ⟨false, false, 0, 0, 0, 0, 0, .ref 0 #[],
+      #[⟨0, .lam linearLocal (.ref 0 #[]) (.var 0)⟩]⟩
+    sharing := #[], refs := #[unit], univs := #[] }
+  let (recEnv, recAddr) := store base recursor
+  check "annotated recursor rules are relevant" (Addressed.checkResources recEnv profile) false
+  check "profile-bound recursor" (Addressed.checkResources recEnv { profile with assumptions := #[recAddr] }) true
+  -- These are adapter/resource tests; the synthetic recursor and literal
+  -- type profile are intentionally not claims of ordinary kernel typing.
+  let fieldType := Ixon.Expr.all ⟨.many, .unique⟩ .unique (.ref 0 #[]) (.recur 0 #[])
+  let aggregate : Constant := {
+    info := .muts #[.indc ⟨false, 0, 0, 0, .sort 0,
+      #[⟨false, 0, 0, 0, 1, fieldType⟩]⟩]
+    sharing := #[], refs := #[unit], univs := #[.zero] }
+  let (fieldEnv, block) := store base aggregate
+  let (fieldEnv, nominal) := store fieldEnv (Addressed.wrapper (.iPrj ⟨0, block⟩))
+  let (fieldEnv, _) := store fieldEnv (Addressed.constructorWrapper block 0 0)
+  let resolved ← get "derived fields" (Addressed.checkResources fieldEnv profile)
+  unless resolved.program.fields.size == 1 &&
+      resolved.addresses[resolved.program.fields[0]!.typeRef.toNat]? == some nominal &&
+      resolved.program.fields[0]!.contract == .unique do
+    throw <| IO.userError "field rule did not come from the addressed constructor"
+  IO.println "Addressed resources: integrity, profile codecs, fixtures, fields, and dependency checks passed"
+
+end Tests.ResourceAddressed
+
+end
diff --git a/Tests/Ix/ResourceAdmit.lean b/Tests/Ix/ResourceAdmit.lean
new file mode 100644
index 000000000..a541b6a52
--- /dev/null
+++ b/Tests/Ix/ResourceAdmit.lean
@@ -0,0 +1,81 @@
+module
+
+public import Tests.Ix.Resource
+public import Ix.Resource.Admit
+
+public section
+
+namespace Tests.Resource
+
+open Ixon Ix.Resource
+
+def policy : Policy := {
+  assumptions := #[1, 4, 6, 8, 9, 10]
+  choices := #[6, 9, 10]
+  shareableTypes := #[0, 7]
+}
+
+def checkAdmission (label : String) (p : Program) (allowed : Bool)
+    (policy : Policy := policy) : IO Unit := do
+  let result := admitProgram p policy
+  unless result.toOption.isSome == allowed do
+    throw <| IO.userError s!"resource admission {label}: expected {allowed}, got {repr result}"
+
+def withConstructor (type : E) : Program :=
+  { program with declarations := program.declarations.push { type, kind := .constructor } }
+
+def runAdmission : IO Unit := do
+  checkAdmission "explicit profile" program true
+  checkAdmission "unadmitted external contract" program false { policy with assumptions := #[6, 9, 10] }
+  checkAdmission "unadmitted selection behavior" program false { policy with choices := #[] }
+  checkAdmission "unadmitted representation" program false { policy with shareableTypes := #[] }
+  let alias := { program with declarations := program.declarations.push {
+    type := arr (b .many)
+    body := some (ref 2) } }
+  checkAdmission "ordinary spelling cannot drop imported contracts" alias false
+  let chain := { alias with declarations := alias.declarations.push {
+    type := arr (b .many)
+    body := some (ref 11) } }
+  let marked ← match relevance chain with
+    | .ok marked => pure marked
+    | .error error => throw <| IO.userError s!"relevance: {repr error}"
+  unless marked[11]! && marked[12]! do
+    throw <| IO.userError "resource relevance did not reach transitive aliases"
+  let group := { program with
+    declarations := program.declarations.push { type := natTy, body := some zero }
+    groups := #[#[2, 11]] }
+  let marked ← match relevance group with
+    | .ok marked => pure marked
+    | .error error => throw <| IO.userError s!"group relevance: {repr error}"
+  unless marked[11]! do throw <| IO.userError "resource relevance skipped a mutual sibling"
+  checkAdmission "mutual sibling checked" group true
+  checkAdmission "linear constructor capture cannot become reusable"
+    (withConstructor (arr (b .linear))) false
+  checkAdmission "linear constructor capture stays unique"
+    (withConstructor (arr (b .linear) .unique)) true
+  checkAdmission "local constructor capture cannot escape"
+    (withConstructor (arr (b .many .localShared))) false
+  checkAdmission "local constructor capture stays local"
+    (withConstructor (arr (b .many .localShared) .localShared)) true
+  checkAdmission "partial constructor cannot forget prior captures"
+    (withConstructor (arr (b .linear) .unique natTy (arr (b .many)))) false
+  checkAdmission "curried constructor preserves every capture"
+    (withConstructor (arr (b .linear) .unique natTy (arr (b .many) .unique))) true
+  checkAdmission "type argument has no constructor capture"
+    (withConstructor (arr (b .erased) .shared (.sort 0) natTy)) true
+  checkAdmission "type argument does not discharge linear consumption"
+    (withConstructor (arr (b .linear) .unique (.sort 0) natTy)) false
+  let mut sharing : Array Ixon.Expr := #[.sort 0]
+  for i in [:40] do
+    sharing := sharing.push (.app (.share i.toUInt64) (.share i.toUInt64))
+  let dag : Program := { declarations := #[{ type := .sort 0, body := some (.share 40) }], sharing }
+  unless (relevance dag { depth := 1, steps := 200 }).toOption == some #[false] do
+    throw <| IO.userError "relevance expanded a shared DAG as a tree"
+  let cyclic := { dag with sharing := #[.share 0], declarations := #[{ type := .sort 0, body := some (.share 0) }] }
+  unless (relevance cyclic).toOption.isNone do throw <| IO.userError "cyclic sharing was admitted"
+  IO.println "Resource admission: 18 profile, dependency, constructor, and DAG checks passed"
+
+end Tests.Resource
+
+end
+
diff --git a/Tests/Ix/ResourceValidate.lean b/Tests/Ix/ResourceValidate.lean
new file mode 100644
index 000000000..083fa576b
--- /dev/null
+++ b/Tests/Ix/ResourceValidate.lean
@@ -0,0 +1,33 @@
+module
+
+public import Ix.Resource.Validate
+public import Tests.Ix.ResourceAddressed
+
+public section
+
+namespace Tests.ResourceValidate
+
+open Ixon Ix.Resource Tests.ResourceAddressed
+
+def run : IO Unit := do
+  let (base, unit) := unitEnv
+  let (env, id) := store base (identity unit)
+  check "combined identity" (validate env {}) true
+  check "literal type pin" (validate env { natType := some unit }) false
+  let bad : Constant := {
+    info := .defn ⟨.defn, .safe, 0, .sort 0, .var 0⟩
+    sharing := #[], refs := #[], univs := #[.zero] }
+  let (malformed, address) := store env bad
+  check "ordinary component skips resource analysis" (Addressed.checkResources malformed {}) true
+  check "ordinary component still needs typing" (validate malformed {}) false
+  let forged := { LazyConstant.ofConstant bad with cache := some (identity unit) }
+  check "typing also ignores materialized cache"
+    (validate { malformed with consts := malformed.consts.insert address forged } {}) false
+  let forged := { LazyConstant.ofConstant (identity unit) with cache := some bad }
+  check "both validators consume the committed bytes"
+    (validate { env with consts := env.consts.insert id forged } {}) true
+  IO.println "Combined resources: typing, literal identities, and raw-byte validation passed"
+
+end Tests.ResourceValidate
+
+end
diff --git a/Tests/Ix/Sharing.lean b/Tests/Ix/Sharing.lean
index 49eaf748f..2b4dd3e65 100644
--- a/Tests/Ix/Sharing.lean
+++ b/Tests/Ix/Sharing.lean
@@ -156,8 +156,8 @@ where
 def testKnownHashVar0 : TestSeq :=
   let e := Expr.var 0
   let h := computeExprHash e
-  -- Hash should be blake3([0x01, 0, 0, 0, 0, 0, 0, 0, 0])
-  let buf := ByteArray.empty.push 0x01 |>.append (uint64ToBytes 0)
+  -- V3 sharing uses the canonical scalar node header: Var(0) is [0x10].
+  let buf := ByteArray.mk #[0x10]
   let expected := Address.blake3 buf
   test "var 0 hash matches expected" (h == expected)
 
@@ -165,8 +165,8 @@ def testKnownHashVar0 : TestSeq :=
 def testKnownHashSort0 : TestSeq :=
   let e := Expr.sort 0
   let h := computeExprHash e
-  -- Hash should be blake3([0x00, 0, 0, 0, 0, 0, 0, 0, 0])
-  let buf := ByteArray.empty.push 0x00 |>.append (uint64ToBytes 0)
+  -- V3 sharing uses the canonical scalar node header: Sort(0) is [0x00].
+  let buf := ByteArray.mk #[0x00]
   let expected := Address.blake3 buf
   test "sort 0 hash matches expected" (h == expected)
 
diff --git a/Tests/Ix/SourceContract.lean b/Tests/Ix/SourceContract.lean
new file mode 100644
index 000000000..1e9255c4b
--- /dev/null
+++ b/Tests/Ix/SourceContract.lean
@@ -0,0 +1,291 @@
+module
+
+public import Ix.Compile.SourceContract
+public import LSpec
+public import Lean.Compiler.BorrowedAnnotation
+
+public section
+
+namespace Tests.Ix.SourceContract
+
+open Lean LSpec
+open Ix.Compile
+
+private def test (description : String) (condition : Bool) : TestSeq :=
+  LSpec.test description (condition = true)
+
+private def natType : Expr := .const `Nat []
+
+private def definition (name : Name) (type value : Expr) : ConstantInfo :=
+  .defnInfo {
+    name, levelParams := [], type, value, hints := .abbrev
+    safety := .safe, all := [name] }
+
+private def identity (name : Name := `identity) : ConstantInfo :=
+  definition name (.forallE `x natType natType .default)
+    (.lam `x natType (.bvar 0) .default)
+
+private def curried : ConstantInfo :=
+  definition `curried
+    (.forallE `x natType (.forallE `y natType natType .default) .implicit)
+    (.lam `x natType (.lam `y natType (.bvar 0) .default) .implicit)
+
+private def resolveTelescope (source : ConstantInfo) (contracts : Array TelescopeContract) :
+    Except SourceContractError ResolvedSourceContract := do
+  (← SourceContract.ofTelescope source contracts).resolve source
+
+private def expectError (actual : Except SourceContractError α) (expected : SourceContractError) : Bool :=
+  match actual with
+  | .error error => error == expected
+  | .ok _ => false
+
+private def resolvedModes (actual : Except SourceContractError ResolvedSourceContract) :
+    Array (BinderSite × Ixon.Uses × Option Ixon.ValueContract) :=
+  match actual with
+  | .error _ => #[]
+  | .ok contract => contract.binders.map fun binder => (binder.site, binder.uses, binder.result)
+
+def telescopeTests : TestSeq :=
+  test "identity resolves linear/unique type and linear body at independent sites"
+    (resolvedModes (resolveTelescope (identity) #[{ binder := .position 0, uses := .linear, result := some .unique }]) ==
+      #[(⟨.type, []⟩, .linear, some .unique), (⟨.body, []⟩, .linear, none)]) ++
+  test "all four usage modes are accepted without inferring resource validity"
+    ([Ixon.Uses.erased, .linear, .affine, .many].all fun uses =>
+      (resolveTelescope (identity) #[{ binder := .position 0, uses, result := some .shared }]).isOk) ++
+  test "ownership shorthand affects only the selected curried arrow"
+    (resolvedModes (resolveTelescope curried #[{ binder := .name `y, uses := .linear, result := some .unique }]) ==
+      #[(⟨.type, [.binderBody]⟩, .linear, some .unique),
+        (⟨.body, [.binderBody]⟩, .linear, none)]) ++
+  test "implicit argument retains its position and does not imply erasure"
+    (match resolveTelescope curried #[{ binder := .position 0, uses := .many }] with
+      | .ok result => result.binders.all fun binder =>
+        binder.binderInfo == .implicit && binder.uses == .many
+      | .error _ => false) ++
+  test "out-of-range elaborated positions are rejected"
+    (expectError (resolveTelescope curried #[{ binder := .position 2, uses := .linear }])
+      (.argumentOutOfRange `curried 2)) ++
+  test "missing binder names are rejected"
+    (expectError (resolveTelescope curried #[{ binder := .name `missing, uses := .linear }])
+      (.unknownBinder `curried `missing)) ++
+  test "name and position annotations cannot silently overwrite the same site"
+    (expectError (resolveTelescope curried #[{ binder := .name `y, uses := .linear },
+      { binder := .position 1, uses := .affine }])
+      (.duplicateSite `curried ⟨.type, [.binderBody]⟩))
+
+def occurrenceTests : TestSeq := Id.run do
+  let lam := Expr.lam `shadow natType (.bvar 0) .default
+  let nested := definition `nested (.forallE `x natType natType .default)
+    (.lam `x natType (.app lam (.app lam (.bvar 0))) .default)
+  let left : BinderSite := ⟨.body, [.binderBody, .appFn]⟩
+  let right : BinderSite := ⟨.body, [.binderBody, .appArg, .appFn]⟩
+  let distinct : SourceContract := {
+    source := nested
+    binders := #[{ site := left, uses := .linear }, { site := right, uses := .affine }] }
+  let shadowed := definition `shadowed
+    (.forallE `x natType (.forallE `x natType natType .default) .default)
+    (.lam `x natType (.lam `x natType (.bvar 0) .default) .default)
+  let wrapped := definition `wrapped
+    (.mdata {} (.forallE `x natType natType .default))
+    (.mdata {} (.lam `x natType (.bvar 0) .default))
+  return test "equal nested lambdas can carry different occurrence contracts"
+      (resolvedModes (distinct.resolve nested) == #[(left, .linear, none), (right, .affine, none)]) ++
+    test "annotation order has a canonical resolved order"
+      (resolvedModes (({ distinct with binders := distinct.binders.reverse }).resolve nested) ==
+        resolvedModes (distinct.resolve nested)) ++
+    test "shadowed declaration binders require an explicit position"
+      (expectError (resolveTelescope shadowed #[{ binder := .name `x, uses := .linear }])
+        (.ambiguousBinder `shadowed `x)) ++
+    test "position disambiguates shadowed declaration binders"
+      ((resolveTelescope shadowed #[{ binder := .position 1, uses := .linear }]).isOk) ++
+    test "metadata wrappers appear in resolved telescope paths"
+      (resolvedModes (resolveTelescope wrapped #[{ binder := .position 0, uses := .linear, result := some .unique }]) ==
+        #[(⟨.type, [.metadata]⟩, .linear, some .unique),
+          (⟨.body, [.metadata]⟩, .linear, none)]) ++
+    test "invalid structural edges fail before canonicalization"
+      (expectError (({ source := identity, binders := #[{ site := ⟨.body, [.appArg]⟩, uses := .linear }] } : SourceContract).resolve identity)
+        (.invalidSite `identity ⟨.body, [.appArg]⟩)) ++
+    test "an expression occurrence must actually be a binder"
+      (expectError (({ source := identity, binders := #[{ site := ⟨.body, [.binderBody]⟩, uses := .linear }] } : SourceContract).resolve identity)
+        (.expectedBinder `identity ⟨.body, [.binderBody]⟩))
+
+def rejectionTests : TestSeq := Id.run do
+  let bodySite : BinderSite := ⟨.body, []⟩
+  let typeSite : BinderSite := ⟨.type, []⟩
+  let contract : SourceContract := {
+    source := identity
+    binders := #[{ site := typeSite, uses := .linear }, { site := bodySite, uses := .linear }] }
+  let renamed := definition `identity (.forallE `renamed natType natType .default)
+    (.lam `renamed natType (.bvar 0) .default)
+  let changedInfo := definition `identity (.forallE `x natType natType .implicit)
+    (.lam `x natType (.bvar 0) .implicit)
+  let changedMetadata := definition `identity (.forallE `x natType natType .default)
+    (.mdata {} (.lam `x natType (.bvar 0) .default))
+  let alias := definition `alias (.forallE `x natType natType .default) (.const `identity [])
+  return test "type/body usage disagreement is rejected"
+      (expectError (({ source := identity, binders := #[{ site := typeSite, uses := .linear }] } : SourceContract).resolve identity)
+        (.inconsistentTelescope `identity 0 .linear .many)) ++
+    test "a lambda has no independent result-ownership field"
+      (expectError (({ source := identity, binders := #[{ site := bodySite, uses := .many, result := some .shared }] } : SourceContract).resolve identity)
+        (.resultOnNonArrow `identity bodySite)) ++
+    test "source binder spelling is part of the occurrence fingerprint"
+      (expectError (contract.resolve renamed) (.staleSource `identity)) ++
+    test "source BinderInfo drift invalidates a previously resolved contract"
+      (expectError (contract.resolve changedInfo) (.staleSource `identity)) ++
+    test "source metadata shape drift invalidates structural paths"
+      (expectError (contract.resolve changedMetadata) (.staleSource `identity)) ++
+    test "unsupported body telescope normalization gets a diagnostic"
+      (expectError (resolveTelescope alias #[{ binder := .position 0, uses := .linear }])
+        (.missingBodyBinder `alias 0))
+
+def inputTests : TestSeq := Id.run do
+  let source := identity
+  let constants := [(source.name, source)]
+  let first : SourceContract := {
+    source
+    binders := #[{ site := ⟨.type, []⟩, uses := .linear }, { site := ⟨.body, []⟩, uses := .linear }] }
+  let second := identity `second
+  let secondContract : SourceContract :=
+    { source := second
+      binders := #[{ site := ⟨.type, []⟩, uses := .affine }, { site := ⟨.body, []⟩, uses := .affine }] }
+  let sameBody : CompileInput :=
+    { constants := constants ++ [(second.name, second)], contracts := #[first, secondContract] }
+  let hinted : CompileInput :=
+    { constants, contracts := #[], measureHints := #[⟨source, .name `x, some 1⟩] }
+  return test "plain input preserves selected source and has no semantic contracts"
+      (match (CompileInput.plain constants).resolve with
+        | .ok result => result.constants == constants && result.contracts.isEmpty
+        | .error _ => false) ++
+    test "equal declaration bodies retain their distinct semantic contracts"
+      (match sameBody.resolve with
+        | .ok result => result.contracts.size == 2 &&
+          result.contracts[0]!.usesAt ⟨.body, []⟩ == .linear &&
+          result.contracts[1]!.usesAt ⟨.body, []⟩ == .affine
+        | .error _ => false) ++
+    test "duplicate selected declarations are rejected"
+      (expectError ((CompileInput.plain (constants ++ constants)).resolve)
+        (.duplicateDeclaration `identity)) ++
+    test "selected names must match their declaration"
+      (expectError ((CompileInput.plain [(`wrong, source)]).resolve)
+        (.declarationNameMismatch `wrong `identity)) ++
+    test "a dangling registry entry cannot be silently dropped"
+      (expectError (({ constants := [], contracts := #[first] } : CompileInput).resolve)
+        (.missingDeclaration `identity)) ++
+    test "duplicate declaration contracts cannot overwrite each other"
+      (expectError (({ constants, contracts := #[first, first] } : CompileInput).resolve)
+        (.duplicateContract `identity)) ++
+    test "measure hints resolve to positions without changing source or modes"
+      (match hinted.resolve with
+        | .ok result => result.constants == constants && result.contracts.isEmpty &&
+          result.measureHints.size == 1 && result.measureHints[0]!.argument == 0 &&
+          result.measureHints[0]!.site == ⟨.type, []⟩
+        | .error _ => false) ++
+    test "zero-step proposals receive a diagnostic"
+      (expectError (({ hinted with measureHints := #[⟨source, .position 0, some 0⟩] }).resolve)
+        (.zeroFixedStep `identity)) ++
+    test "multiple measure proposals for one declaration are rejected"
+      (expectError (({ hinted with measureHints := hinted.measureHints ++ hinted.measureHints }).resolve)
+        (.duplicateMeasure `identity))
+
+def valueContractTests : TestSeq := Id.run do
+  let source := identity
+  let typeSite : BinderSite := ⟨.type, []⟩
+  let bodySite : BinderSite := ⟨.body, []⟩
+  let unique : TelescopeContract := { binder := .position 0, uses := .many, value := .unique }
+  let ownershipMismatch : SourceContract := {
+    source, binders := #[{ site := typeSite, uses := .many, value := .unique }] }
+  let localityMismatch : SourceContract := {
+    source, binders := #[{ site := typeSite, uses := .many, value := .localShared }] }
+  let values : List Ixon.ValueContract := [.shared, .unique, .localShared, .localUnique]
+  let modes : List Ixon.Uses := [.erased, .linear, .affine, .many]
+  let binding := definition `binding natType (.letE `view natType (.const `owner []) (.bvar 0) false)
+  let borrow : SourceContract := {
+    source := binding
+    binders := #[{ site := bodySite, uses := .affine, value := .localShared, letKind := .borrowShared }] }
+  return test "unique input is independent of the arrow result"
+      (match resolveTelescope source #[unique] with
+        | .ok result => result.valueAt typeSite == .unique && result.valueAt bodySite == .unique &&
+          result.usesAt typeSite == .many &&
+          (result.binders.find? (·.site == typeSite)).bind (·.result) == some .shared
+        | .error _ => false) ++
+    test "all 64 arrow contracts preserve input, result, and matching lambda fields"
+      (modes.all fun uses => values.all fun value => values.all fun output =>
+        match resolveTelescope source #[{ binder := .position 0, uses, value, result := some output }] with
+        | .ok c => c.valueAt typeSite == value && c.valueAt bodySite == value &&
+          c.usesAt typeSite == uses && c.usesAt bodySite == uses &&
+          (c.binders.find? (·.site == typeSite)).bind (·.result) == some output
+        | .error _ => false) ++
+    test "type and body must agree on ownership"
+      (expectError (ownershipMismatch.resolve source)
+        (.inconsistentValue `identity 0 .unique .shared)) ++
+    test "type and body must agree on locality"
+      (expectError (localityMismatch.resolve source)
+        (.inconsistentValue `identity 0 .localShared .shared)) ++
+    test "borrow let retains its explicit kind and shared local view"
+      (match borrow.resolve binding with
+        | .ok c => c.binders[0]!.kind == .letE && c.binders[0]!.letKind == .borrowShared &&
+          c.binders[0]!.value == .localShared && c.binders[0]!.result.isNone
+        | .error _ => false) ++
+    test "a shared borrow cannot manufacture unique ownership"
+      (expectError (({ borrow with binders := borrow.binders.map fun (b : BinderContract) => { b with value := .localUnique } }).resolve binding)
+        (.invalidBorrowView `binding bodySite)) ++
+    test "a borrow flag cannot annotate a function binder"
+      (expectError (resolveTelescope source #[{ unique with letKind := .borrowShared }])
+        (.borrowOnNonLet `identity typeSite))
+
+def markerTests : TestSeq := Id.run do
+  let annotation : BinderAnnotation := {
+    origin := 0, binder := `x, uses := .affine, value := .localUnique }
+  let data := annotation.toMetadata
+  let borrowed := Lean.markBorrowed natType
+  let duplicate := { data with entries := (sourceAnnotationKey, .ofNat 1) :: data.entries }
+  let missingVersion := ({} : Lean.MData).setNat `ix.source.binder.uses 1
+  let marked := definition `marked
+    (.forallE `x (.mdata data natType) natType .default)
+    (.lam `x natType (.bvar 0) .default)
+  let input := CompileInput.plain [(marked.name, marked)]
+  let recursor : ConstantInfo := .recInfo {
+    name := `markedRecursor, levelParams := [], type := .sort .zero
+    all := [], numParams := 0, numIndices := 0, numMotives := 0, numMinors := 0
+    rules := [⟨`constructor, 0, .mdata missingVersion natType⟩]
+    k := false, isUnsafe := false }
+  let shared := (List.range 28).foldl (fun expr _ => Expr.app expr expr) natType
+  return test "source annotation metadata roundtrips ownership, usage, locality, and origin"
+      (match BinderAnnotation.ofMetadata? data with
+        | .ok decoded => decoded == some annotation
+        | .error _ => false) ++
+    test "adding source markers preserves Lean's singleton native borrow wrapper"
+      (match annotation.attach borrowed with
+        | .ok type => Lean.isMarkedBorrowed type &&
+          match binderAnnotation? type with
+          | .ok decoded => decoded == some annotation
+          | .error _ => false
+        | .error _ => false) ++
+    test "strict source metadata rejects unknown keys, duplicates, versions, and overflowing modes"
+      ([data.setNat `ix.source.binder.future 0, duplicate, missingVersion,
+        data.setNat sourceAnnotationKey 2, data.setNat `ix.source.binder.uses 256,
+        data.setNat `ix.source.binder.owned 256].all fun malformed =>
+          !(BinderAnnotation.ofMetadata? malformed).isOk) ++
+    test "malformed reserved metadata is still detected by the preflight"
+      (exprHasSourceAnnotations (.mdata missingVersion natType)) ++
+    test "source markers in raw recursor rules are detected and explicitly unsupported"
+      (sourceHasAnnotations recursor &&
+        expectError (SourceContract.fromAnnotations recursor) (.annotatedRecursorRule recursor.name)) ++
+    test "annotation scan handles heavily shared ordinary source and nearby markers"
+      (!exprHasSourceAnnotations shared &&
+        exprHasSourceAnnotations (.app shared (.mdata data natType))) ++
+    test "source markers require explicit matching records and cannot be overridden"
+      (expectError input.resolve (.missingContract marked.name) &&
+        match SourceContract.fromAnnotations marked with
+        | .ok contract =>
+          let changed : SourceContract := { contract with
+            binders := contract.binders.map fun binder => { binder with value := .shared } }
+          contract.binders.size == 2 && (contract.resolve marked).isOk &&
+          !(changed.resolve marked).isOk
+        | .error _ => false)
+
+def suite : List TestSeq :=
+  [telescopeTests, occurrenceTests, rejectionTests, inputTests, valueContractTests, markerTests]
+
+end Tests.Ix.SourceContract
+
+end
diff --git a/Tests/Ix/SourceContract/Driver.lean b/Tests/Ix/SourceContract/Driver.lean
new file mode 100644
index 000000000..8a2af8c6d
--- /dev/null
+++ b/Tests/Ix/SourceContract/Driver.lean
@@ -0,0 +1,75 @@
+module
+
+public import LSpec
+public import Ix.CompileDriver
+
+public section
+
+namespace Tests.Ix.SourceContract.Driver
+
+open Lean LSpec Ix.Compile Ix.CompileM
+
+private def plainSource : ConstantInfo := .axiomInfo {
+  name := `SourceContractDriver.identityType, levelParams := []
+  type := .forallE `x (.sort .zero) (.sort .zero) .default
+  isUnsafe := false }
+
+private def annotation : BinderAnnotation := {
+  origin := 0, binder := `x, uses := .affine, value := .localUnique }
+
+private def markedSource : ConstantInfo := .axiomInfo {
+  name := plainSource.name, levelParams := []
+  type := .forallE `x (.mdata annotation.toMetadata (.sort .zero)) (.sort .zero) .default
+  isUnsafe := false }
+
+private def constants (source : ConstantInfo) := [(source.name, source)]
+
+private def ioTest (description : String) (check : IO Bool) : TestSeq :=
+  .individualIO description none (do return (← check, 0, 0, none)) .done
+
+private def unsupported (result : Except String α) : Bool :=
+  match result with
+  | .error message => (message.splitOn "external resource interface is absent").length > 1
+  | .ok _ => false
+
+def suite : List TestSeq := [
+  ioTest "Lean constant-list driver rejects an unadmitted annotated axiom" do
+    return unsupported (← compileLeanConsts (constants markedSource) (numWorkers := 1)),
+  ioTest "explicit Lean input rejects a missing annotation registry" do
+    match ← compileLeanInput (.plain (constants markedSource)) (numWorkers := 1) with
+    | .error message => return (message.splitOn "missingContract").length > 1
+    | .ok _ => return false,
+  ioTest "explicit Lean input requires an assumption for an annotated axiom" do
+    let .ok contract := SourceContract.ofTelescope plainSource #[
+      { binder := .position 0, uses := .linear }]
+      | return false
+    let input : CompileInput := { constants := constants plainSource, contracts := #[contract] }
+    return unsupported (← compileLeanInput input (numWorkers := 1)),
+  ioTest "measure-only input preserves ordinary production bytes" do
+    let input := CompileInput.plain (constants plainSource)
+    let .ok plain ← compileLeanInput input (numWorkers := 1) | return false
+    let hinted := { input with measureHints := #[⟨plainSource, .position 0, some 1⟩] }
+    let .ok measured ← compileLeanInput hinted (numWorkers := 1) | return false
+    return plain.bytes == measured.bytes,
+  ioTest "Rust FFI rejects source contracts without creating an artifact in either output mode" do
+    let directory ← IO.FS.createTempDir
+    try
+      for allowPartial in [false, true] do
+        let output := directory / s!"contracts-{allowPartial}.ixe"
+        let rejected ← try
+          let _ ← rsCompileEnvBytesFFI (constants markedSource) output.toString allowPartial
+          pure false
+        catch error =>
+          pure ((error.toString.splitOn "unresolved source binder contracts").length > 1)
+        if !rejected || (← output.pathExists) ||
+            (← (System.FilePath.mk (output.toString ++ ".tmp")).pathExists) then
+          return false
+      return true
+    finally
+      IO.FS.removeDirAll directory
+]
+
+end Tests.Ix.SourceContract.Driver
+
+end
+
diff --git a/Tests/Ix/SourceContract/ImportCheck.lean b/Tests/Ix/SourceContract/ImportCheck.lean
new file mode 100644
index 000000000..2c3dfec18
--- /dev/null
+++ b/Tests/Ix/SourceContract/ImportCheck.lean
@@ -0,0 +1,69 @@
+import Tests.Ix.SourceContract.Imported
+
+/- This module is elaborated in a separate process after Imported.olean exists.
+It deliberately does not rerun that module's registration commands. -/
+
+open Lean Ix.Compile
+
+run_cmd do
+  let identity ← getConstInfo ``Tests.Ix.SourceContract.Imported.identity
+  let instanceSource ← getConstInfo ``Tests.Ix.SourceContract.Imported.withInstance
+  let opaqueSource ← getConstInfo ``Tests.Ix.SourceContract.Imported.opaqueIdentity
+  let selected := [(identity.name, identity), (instanceSource.name, instanceSource),
+    (opaqueSource.name, opaqueSource)]
+  let .ok input := compileInputFromEnv (← getEnv) selected
+    | throwError "imported contract export failed"
+  let .ok resolved := input.resolve
+    | throwError "imported contract resolution failed"
+  unless resolved.contracts.size == 3 && resolved.measureHints.size == 1 do
+    throwError "imported registrations were lost"
+  let some contract := resolved.contracts.find? (·.source.name == identity.name)
+    | throwError "imported identity contract is absent"
+  unless contract.usesAt ⟨.type, []⟩ == .linear && contract.usesAt ⟨.body, []⟩ == .linear do
+    throwError "imported identity modes changed"
+  unless (contract.binders.find? (·.site == ⟨.type, []⟩)).bind (·.result) == some .localUnique do
+    throwError "imported result ownership changed"
+  let hint := resolved.measureHints[0]!
+  unless hint.source.name == identity.name && hint.argument == 0 && hint.fixedStep == some 1 do
+    throwError "imported measure mapping changed"
+  let some contract := resolved.contracts.find? (·.source.name == instanceSource.name)
+    | throwError "imported instance fixture contract is absent"
+  unless contract.usesAt ⟨.type, [.binderBody, .binderBody]⟩ == .affine do
+    throwError "implicit or instance positions were omitted"
+  let some contract := resolved.contracts.find? (·.source.name == opaqueSource.name)
+    | throwError "imported opaque fixture contract is absent"
+  unless contract.usesAt ⟨.body, []⟩ == .linear do
+    throwError "opaque declaration body contract was lost"
+
+  -- Unselected registrations do not pollute the explicit selected input.
+  let .ok empty := compileInputFromEnv (← getEnv) []
+    | throwError "empty selected input should export"
+  unless empty.contracts.isEmpty && empty.measureHints.isEmpty do
+    throwError "unselected registrations leaked into an export"
+
+  -- Simulate conflicting patches arriving from independently imported modules.
+  -- The extension must retain both so export can reject, rather than overwrite.
+  let some duplicate := input.contracts.find? (·.source.name == identity.name)
+    | throwError "identity input contract is absent"
+  let conflicting := { duplicate with
+    binders := duplicate.binders.map fun binder => { binder with uses := .affine } }
+  let forgedEnv := sourceContractExtension.addEntry (← getEnv) conflicting
+  match compileInputFromEnv forgedEnv selected with
+  | .error (.duplicateSite name _) =>
+    unless name == identity.name do throwError "wrong conflicting declaration"
+  | _ => throwError "conflicting imported patches silently overwrote a contract"
+
+  -- An additional, disjoint patch must preserve the already-imported sites.
+  let .ok extra := SourceContract.ofTelescope instanceSource #[{ binder := .position 0, uses := .erased }]
+    | throwError "additional telescope patch failed to resolve"
+  let .ok extendedEnv := registerSourceContract (← getEnv) extra
+    | throwError "disjoint imported registration patch was rejected"
+  let .ok extendedInput := compileInputFromEnv extendedEnv selected
+    | throwError "extended registration failed to export"
+  let .ok extended := extendedInput.resolve
+    | throwError "extended registration failed to resolve"
+  let some contract := extended.contracts.find? (·.source.name == instanceSource.name)
+    | throwError "extended instance contract is absent"
+  unless contract.usesAt ⟨.type, []⟩ == .erased &&
+      contract.usesAt ⟨.type, [.binderBody, .binderBody]⟩ == .affine do
+    throwError "disjoint patches did not preserve both contracts"
diff --git a/Tests/Ix/SourceContract/Imported.lean b/Tests/Ix/SourceContract/Imported.lean
new file mode 100644
index 000000000..ff900bdda
--- /dev/null
+++ b/Tests/Ix/SourceContract/Imported.lean
@@ -0,0 +1,42 @@
+module
+
+public import Ix.Compile.SourceContract.Registry
+public meta import Ix.Compile.SourceContract.Resolve
+public meta import Ix.Compile.SourceContract.Registry
+
+public section
+
+namespace Tests.Ix.SourceContract.Imported
+
+def identity (x : Nat) : Nat := x
+
+def withInstance {α : Type} [Inhabited α] (x : Nat) : Nat := x
+
+opaque opaqueIdentity (x : Nat) : Nat := x
+
+open Lean Ix.Compile in
+run_cmd do
+  let source ← getConstInfo ``identity
+  let .ok contract := SourceContract.ofTelescope source #[{ binder := .name `x, uses := .linear, result := some .localUnique }]
+    | throwError "failed to resolve imported identity fixture"
+  let .ok env := registerSourceContract (← getEnv) contract
+    | throwError "failed to register imported identity fixture"
+  let .ok env := registerMeasureHint env ⟨source, .name `x, some 1⟩
+    | throwError "failed to register imported measure fixture"
+  setEnv env
+  let source ← getConstInfo ``withInstance
+  let .ok contract := SourceContract.ofTelescope source #[{ binder := .position 2, uses := .affine }]
+    | throwError "failed to resolve implicit/instance fixture"
+  let .ok env := registerSourceContract (← getEnv) contract
+    | throwError "failed to register implicit/instance fixture"
+  setEnv env
+  let source ← getConstInfo ``opaqueIdentity
+  let .ok contract := SourceContract.ofTelescope source #[{ binder := .position 0, uses := .linear }]
+    | throwError "failed to resolve opaque-body fixture"
+  let .ok env := registerSourceContract (← getEnv) contract
+    | throwError "failed to register opaque-body fixture"
+  setEnv env
+
+end Tests.Ix.SourceContract.Imported
+
+end
diff --git a/Tests/Ix/SourceContract/SyntaxCheck.lean b/Tests/Ix/SourceContract/SyntaxCheck.lean
new file mode 100644
index 000000000..03c74cb73
--- /dev/null
+++ b/Tests/Ix/SourceContract/SyntaxCheck.lean
@@ -0,0 +1,182 @@
+import Tests.Ix.SourceContract.SyntaxFixture
+
+open Lean Ix.Compile
+
+run_cmd do
+  let names := #[
+    ``Tests.Ix.SourceContract.SyntaxFixture.linear,
+    ``Tests.Ix.SourceContract.SyntaxFixture.unique,
+    ``Tests.Ix.SourceContract.SyntaxFixture.uniqueAffine,
+    ``Tests.Ix.SourceContract.SyntaxFixture.erased,
+    ``Tests.Ix.SourceContract.SyntaxFixture.inferred,
+    ``Tests.Ix.SourceContract.SyntaxFixture.dependent,
+    ``Tests.Ix.SourceContract.SyntaxFixture.inferredImplicit,
+    ``Tests.Ix.SourceContract.SyntaxFixture.withInstance,
+    ``Tests.Ix.SourceContract.SyntaxFixture.strictImplicit,
+    ``Tests.Ix.SourceContract.SyntaxFixture.shadowed,
+    ``Tests.Ix.SourceContract.SyntaxFixture.nativeBorrow,
+    ``Tests.Ix.SourceContract.SyntaxFixture.twoLocal,
+    ``Tests.Ix.SourceContract.SyntaxFixture.renamedLocal,
+    ``Tests.Ix.SourceContract.SyntaxFixture.renamedTwoLocal,
+    ``Tests.Ix.SourceContract.SyntaxFixture.localShared,
+    ``Tests.Ix.SourceContract.SyntaxFixture.localUnique,
+    ``Tests.Ix.SourceContract.SyntaxFixture.localResult,
+    ``Tests.Ix.SourceContract.SyntaxFixture.localUniqueResult,
+    ``Tests.Ix.SourceContract.SyntaxFixture.curriedResult,
+    ``Tests.Ix.SourceContract.SyntaxFixture.dependentArrow,
+    ``Tests.Ix.SourceContract.SyntaxFixture.anonymousArrow,
+    ``Tests.Ix.SourceContract.SyntaxFixture.quantified,
+    ``Tests.Ix.SourceContract.SyntaxFixture.nestedLambda,
+    ``Tests.Ix.SourceContract.SyntaxFixture.lambdaDefinition,
+    ``Tests.Ix.SourceContract.SyntaxFixture.localLet,
+    ``Tests.Ix.SourceContract.SyntaxFixture.sharedLoan]
+  let selected ← names.toList.mapM fun name => do return (name, ← getConstInfo name)
+  let input ← match compileInputFromEnv (← getEnv) selected with
+    | .ok input => pure input
+    | .error error => throwError "{error}"
+  let resolved ← match input.resolve with
+    | .ok input => pure input
+    | .error error => throwError "{error}"
+  unless resolved.contracts.size == names.size do throwError "syntax registrations were lost on import"
+  unless resolved.measureHints.size == 1 && resolved.measureHints[0]!.argument == 0 do
+    throwError "measure hint on annotated source was lost on import"
+  let getContract (name : Name) := do
+    let some contract := resolved.contracts.find? (·.source.name == name)
+      | throwError "missing syntax contract {name}"
+    pure contract
+  let unique ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.unique
+  unless unique.valueAt ⟨.type, []⟩ == .unique && unique.valueAt ⟨.body, []⟩ == .unique &&
+      unique.usesAt ⟨.type, []⟩ == .many do
+    throwError "unique unrestricted binder changed meaning"
+  unless (unique.binders.find? (·.site == ⟨.type, []⟩)).bind (·.result) == some .shared do
+    throwError "unique input silently changed the result ownership"
+  let native ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.nativeBorrow
+  unless native.usesAt ⟨.type, []⟩ == .affine && native.valueAt ⟨.type, []⟩ == .localUnique &&
+      native.valueAt ⟨.body, []⟩ == .localUnique do
+    throwError "combined ownership, usage, and locality changed on import"
+  let .forallE _ domain _ _ := native.source.type | throwError "native fixture has no binder"
+  unless isMarkedBorrowed domain do throwError "source marker hid Lean's native borrow annotation"
+  let pair ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.twoLocal
+  unless pair.valueAt ⟨.type, []⟩ == .localUnique &&
+      pair.valueAt ⟨.type, [.binderBody]⟩ == .localShared do
+    throwError "distinct local ownership modes were conflated"
+  let renamed ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.renamedLocal
+  unless renamed.semantics == native.semantics do
+    throwError "term binder renaming changed the resolved assertions"
+  let renamedPair ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.renamedTwoLocal
+  unless renamedPair.semantics == pair.semantics do
+    throwError "renaming multiple term binders changed the resolved assertions"
+  let unrestricted ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.localShared
+  unless unrestricted.usesAt ⟨.body, []⟩ == .many &&
+      unrestricted.valueAt ⟨.body, []⟩ == .localShared do
+    throwError "locality-only prefix changed usage or ownership defaults"
+  let dependent ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.dependent
+  unless dependent.usesAt ⟨.type, []⟩ == .erased &&
+      dependent.usesAt ⟨.body, [.binderBody]⟩ == .linear do
+    throwError "implicit parameter shifted the explicit annotation"
+  let inferred ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.inferredImplicit
+  unless inferred.usesAt ⟨.type, []⟩ == .many &&
+      inferred.usesAt ⟨.type, [.binderBody]⟩ == .linear do
+    throwError "an auto-implicit parameter received the explicit binder's annotation"
+  let instanceContract ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.withInstance
+  unless (instanceContract.binders.find? (·.site == ⟨.type, [.binderBody]⟩)).map (·.binderInfo) ==
+      some .instImplicit do
+    throwError "annotated instance binder lost its BinderInfo"
+  let shadowed ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.shadowed
+  unless shadowed.usesAt ⟨.body, []⟩ == .linear &&
+      shadowed.usesAt ⟨.body, [.binderBody]⟩ == .affine do
+    throwError "shadowed binder names were used as occurrence identities"
+  let outputAt (c : ResolvedSourceContract) (site : BinderSite) :=
+    ((c.binders.find? (·.site == site)).bind (·.result)).getD Ixon.ValueContract.shared
+  let localResult ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.localResult
+  unless outputAt localResult ⟨.type, []⟩ == .localShared &&
+      localResult.valueAt ⟨.body, []⟩ == .localShared do
+    throwError "local result or matching input was dropped"
+  let localUnique ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.localUniqueResult
+  unless outputAt localUnique ⟨.type, []⟩ == .localUnique &&
+      localUnique.valueAt ⟨.body, []⟩ == .localUnique &&
+      localUnique.usesAt ⟨.body, []⟩ == .linear do
+    throwError "local unique result changed another axis"
+  let curried ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.curriedResult
+  unless outputAt curried ⟨.type, []⟩ == .shared &&
+      outputAt curried ⟨.type, [.binderBody]⟩ == .localShared do
+    throwError "a final result contract leaked into an intermediate arrow"
+  for name in #[``Tests.Ix.SourceContract.SyntaxFixture.dependentArrow,
+      ``Tests.Ix.SourceContract.SyntaxFixture.quantified] do
+    let c ← getContract name
+    unless outputAt c ⟨.type, []⟩ == .localShared &&
+        c.valueAt ⟨.type, []⟩ == .localShared &&
+        c.valueAt ⟨.body, []⟩ == .localShared do
+      throwError "nested arrow or alpha-renamed lambda lost its contract"
+  let anonymous ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.anonymousArrow
+  unless outputAt anonymous ⟨.type, []⟩ == .localUnique &&
+      anonymous.valueAt ⟨.body, []⟩ == .shared do
+    throwError "an anonymous arrow confused its input and result contracts"
+  for name in #[``Tests.Ix.SourceContract.SyntaxFixture.nestedLambda,
+      ``Tests.Ix.SourceContract.SyntaxFixture.lambdaDefinition] do
+    let c ← getContract name
+    unless c.binders.any (fun b => b.kind == .lam && b.uses == .linear && b.value == .localShared) do
+      throwError "a nested lambda annotation was lost"
+  let localLet ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.localLet
+  unless localLet.binders.any (fun b => b.kind == .letE && b.letKind == .value &&
+      b.uses == .linear && b.value == .localUnique) do
+    throwError "ordinary local let lost a contract field"
+  let loan ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.sharedLoan
+  unless loan.binders.any (fun b => b.kind == .letE && b.letKind == .borrowShared &&
+      b.uses == .many && b.value == .localShared) do
+    throwError "explicit shared borrowing became an ordinary let"
+  for (_, source) in selected do
+    for expr in [source.type] ++ (sourceBody? source).toList do
+      if (expr.find? (·.isConstOf ``sorryAx)).isSome then
+        throwError "source annotation elaboration introduced a proof placeholder"
+
+  let registry := sourceContractExtension.getState (← getEnv)
+  unless registry.toArray.any (fun (name, _) => name.toString.endsWith ".privateIdentity") do
+    throwError "private annotated declaration was not registered"
+  let ordinary ← getConstInfo ``Tests.Ix.SourceContract.SyntaxFixture.ordinaryBinder
+  let .ok plain := compileInputFromEnv (← getEnv) [(ordinary.name, ordinary)]
+    | throwError "ordinary source no longer exports"
+  unless plain.contracts.isEmpty do throwError "ordinary binders gained semantic contracts"
+  match (CompileInput.plain selected).resolve with
+  | .error (.missingContract _) => pure ()
+  | _ => throwError "annotated source accepted an omitted registry"
+
+  -- Test rejected spellings without depending on parser error pretty-printing.
+  for text in [
+      "def bad (!x : Nat) : Nat := x",
+      "def bad (!&x : Nat) : Nat := x",
+      "def bad (&!'a x : Nat) : Nat := x"] do
+    if (Parser.runParserCategory (← getEnv) `command text).isOk then
+      throwError "invalid binder spelling was accepted: {text}"
+
+/-- error: binder usage must be 0, 1, or & -/
+#guard_msgs in
+def invalidQuantity (2 x : Nat) : Nat := x
+
+/-- error: binder annotation components must be adjacent -/
+#guard_msgs in
+def separatedPrefix (! & x : Nat) : Nat := x
+
+/-- error: duplicate ownership annotation -/
+#guard_msgs in
+def duplicateOwnership (!! x : Nat) : Nat := x
+
+/-- error: duplicate locality annotation -/
+#guard_msgs in
+def duplicateLocality (~~ x : Nat) : Nat := x
+
+/-- error: duplicate usage annotation -/
+#guard_msgs in
+def duplicateUsage (1& x : Nat) : Nat := x
+
+/-- error: a shared borrow requires a shared local view (~) -/
+#guard_msgs in
+def invalidUniqueLoan (! owner : Nat) : Nat :=
+  let borrow (~! view : Nat) := owner
+  view
+
+/-- error: a shared borrow requires a shared local view (~) -/
+#guard_msgs in
+def invalidEscapingLoan (! owner : Nat) : Nat :=
+  let borrow (& view : Nat) := owner
+  view
diff --git a/Tests/Ix/SourceContract/SyntaxFixture.lean b/Tests/Ix/SourceContract/SyntaxFixture.lean
new file mode 100644
index 000000000..3476dac28
--- /dev/null
+++ b/Tests/Ix/SourceContract/SyntaxFixture.lean
@@ -0,0 +1,72 @@
+module
+
+public import Ix.Compile.SourceContract.Elab
+public meta import Ix.Compile.SourceContract.Registry
+
+public section
+
+namespace Tests.Ix.SourceContract.SyntaxFixture
+
+def linear (1 x : Nat) : Nat := x
+def unique (! x : Nat) : Nat := x
+def uniqueAffine (!& x : Nat) : Nat := x
+def erased (0 _x : Nat) : Nat := 7
+def inferred (1 x : Nat) := x
+
+def dependent {0 α : Type} (1 x : α) : α := x
+def inferredImplicit (1 x : α) : α := x
+def withInstance {0 α : Type} [& inst : Inhabited α] : α := default
+def strictImplicit ⦃0 α : Type⦄ (1 x : α) : α := x
+def shadowed (1 _x : Nat) (& _x : Nat) : Nat := _x
+
+def nativeBorrow (~!& x : @& Nat) : Nat := x
+
+def twoLocal (~!& x : Nat) (1~ y : Nat) : Nat := x + y
+
+def renamedLocal (~!& value : Nat) : Nat := value
+
+def renamedTwoLocal (~!& first : Nat) (1~ second : Nat) : Nat := first + second
+
+def localShared (~ x : Nat) : Nat := x
+
+def localUnique (~! x : Nat) : Nat := x
+
+@[inline] private def privateIdentity (!1 x : Nat) : Nat := x
+
+def localResult (~ x : Nat) : ~ Nat := x
+def localUniqueResult (~!1 x : Nat) : ~! Nat := x
+def curriedResult (x y : Nat) : ~ Nat := x + y
+def dependentArrow : (~ _x : Nat) → ~ Nat := fun x => x
+def anonymousArrow : Nat → ~! Nat := fun x => x
+def quantified : ∀ (~ _x : Nat), ~ Nat := fun x => x
+def nestedLambda (x : Nat) : Nat := (fun (~1 y : Nat) => y) x
+def lambdaDefinition := fun (~1 x : Nat) => x
+def localLet (x : Nat) : Nat :=
+  let (~!1 y : Nat) := x
+  y
+def sharedLoan (!1 owner : Nat) : Nat :=
+  let borrow (~ view : Nat) := owner
+  view
+
+def privateDeclaration : Lean.Name := ``privateIdentity
+
+-- Ordinary notation must still use Lean's parsers and elaborators.
+def ordinaryChar : Char := 'a'
+def ordinaryNumber : Nat := 1
+def ordinaryBinder (x : Nat) : Nat := x
+def ordinaryRegions (regions : Nat) : Nat := regions
+
+run_cmd do
+  let source ← Lean.getConstInfo ``linear
+  match Ix.Compile.registerMeasureHint (← Lean.getEnv) ⟨source, .position 0, some 1⟩ with
+  | .ok env => Lean.setEnv env
+  | .error error => Lean.throwError m!"{error}"
+
+example : linear 3 = 3 := rfl
+example : twoLocal 2 5 = 7 := rfl
+example : privateIdentity 4 = 4 := rfl
+example : ordinaryChar = 'a' := rfl
+
+end Tests.Ix.SourceContract.SyntaxFixture
+
+end
diff --git a/Tests/Ix/Tc/Roundtrip.lean b/Tests/Ix/Tc/Roundtrip.lean
index 44a990b5b..11c0cb15f 100644
--- a/Tests/Ix/Tc/Roundtrip.lean
+++ b/Tests/Ix/Tc/Roundtrip.lean
@@ -136,7 +136,7 @@ def envLetDefn : Ixon.Env × Address := Id.run do
   let (env, aAddr) := envA
   let c : Ixon.Constant :=
     ⟨.defn ⟨.defn, .safe, 0, .ref 0 #[],
-      .letE true (.ref 0 #[]) (.ref 0 #[]) (.var 0)⟩,
+      .letE (.lean true) (.ref 0 #[]) (.ref 0 #[]) (.var 0)⟩,
      #[], #[aAddr], #[]⟩
   let addr := Address.blake3 (Ixon.serConstant c)
   return (env.storeConst addr c, addr)
diff --git a/Tests/IxonV3Handoff.lean b/Tests/IxonV3Handoff.lean
new file mode 100644
index 000000000..61f0c276c
--- /dev/null
+++ b/Tests/IxonV3Handoff.lean
@@ -0,0 +1,52 @@
+module
+
+public import Tests.Ix.ResourceAddressed
+public import Ix.Resource.Claim
+
+public section
+
+namespace Tests.IxonV3Handoff
+
+/-- A complete anonymous environment and its native resource admission claim.
+The rejected fixture differs only in the escaping result contract. -/
+def artifacts : Except String (Array (String × ByteArray)) := do
+  let (base, unit) := Tests.ResourceAddressed.unitEnv
+  let (accepted, _) := Tests.ResourceAddressed.store base
+    (Tests.ResourceAddressed.identity unit)
+  let (rejected, _) := Tests.ResourceAddressed.store base
+    (Tests.ResourceAddressed.identity unit Tests.ResourceAddressed.linearLocal .shared)
+  let profile : Ix.Resource.Profile := {}
+  let claim ← Ix.Resource.makeClaim accepted profile
+  if (Ix.Resource.validate rejected profile).toOption.isSome then
+    throw "handoff: local escape fixture must be rejected"
+  let profileAddress ← profile.address
+  let files := #[
+    ("accepted.ixe", ← Ixon.serEnv accepted),
+    ("rejected-local-escape.ixe", ← Ixon.serEnv rejected),
+    ("profile.bin", profile.bytes),
+    ("accepted.claim", Ix.Claim.ser claim) ]
+  let manifest := Lean.Json.mkObj [
+    ("schema", .str "ixon-v3-handoff-1"),
+    ("objectFormat", .str "ixon-v3"),
+    ("validator", .str Ix.Resource.validatorId),
+    ("subject", .str (toString accepted.merkleRoot.get!)),
+    ("profile", .str (toString profileAddress)),
+    ("claim", .str (toString (Ix.Claim.commit claim))),
+    ("files", Lean.Json.mkObj (files.toList.map fun (name, bytes) =>
+      (name, .str (toString (Address.blake3 bytes))))),
+    ("ixvmResourceProof", .bool false) ]
+  return files.push ("manifest.json", (manifest.pretty ++ "\n").toUTF8)
+
+def writeArtifacts (directory : System.FilePath) : IO Unit := do
+  IO.FS.createDirAll directory
+  for (name, bytes) in ← IO.ofExcept artifacts do
+    IO.FS.writeBinFile (directory / name) bytes
+
+def check (directory : System.FilePath) : IO Unit := do
+  for (name, bytes) in ← IO.ofExcept artifacts do
+    unless (← IO.FS.readBinFile (directory / name)) == bytes do
+      throw <| IO.userError s!"handoff fixture differs: {name}"
+
+end Tests.IxonV3Handoff
+
+end
diff --git a/Tests/IxonV3Main.lean b/Tests/IxonV3Main.lean
new file mode 100644
index 000000000..005803403
--- /dev/null
+++ b/Tests/IxonV3Main.lean
@@ -0,0 +1,53 @@
+import Tests.Ix.IxonV3
+import Tests.Ix.IxonV3FFI
+import Tests.Ix.IxonV3VM
+import Tests.Ix.IxonV3Text
+import Tests.Ix.ResourceAdmit
+import Tests.Ix.ResourceAddressed
+import Tests.Ix.ResourceValidate
+import Tests.Ix.ContractTransport
+import Tests.Ix.ContractPipeline
+import Tests.Ix.ContractDecompile
+import Tests.Ix.ClaimsV3
+import Tests.Ix.Catalog
+import Tests.Ix.Kernel.PrimAddrs
+import Tests.Ix.SourceContract
+import Tests.Ix.SourceContract.ImportCheck
+import Tests.Ix.SourceContract.SyntaxCheck
+import Tests.Ix.SourceContract.Driver
+import Tests.IxonV3Handoff
+
+def main (args : List String) : IO Unit := do
+  if args.contains "--export-handoff" then
+    Tests.IxonV3Handoff.writeArtifacts "/tmp/ixon-v3-handoff"
+  else
+    Tests.IxonV3Handoff.check "Tests/Fixtures/ixon-v3/handoff"
+  let cases ← Tests.IxonV3.readExprCases
+  let checks ← Tests.IxonV3.runGolden cases
+  IO.println s!"Ixon v3: {checks} golden byte and rejection checks passed"
+  let ffiChecks ← Tests.IxonV3.runFFI cases
+  IO.println s!"Ixon v3: {ffiChecks} FFI, byte parity, and sharing hash checks passed"
+  let vmChecks ← Tests.IxonV3.runVM cases
+  IO.println s!"Ixon v3: {vmChecks} VM execution, interpretation, and proof checks passed"
+  let textChecks ← Tests.IxonV3.runText
+  IO.println s!"Ixon v3: {textChecks} text contract and rejection checks passed"
+  Tests.Resource.run
+  Tests.Resource.runAdmission
+  Tests.ResourceAddressed.run
+  Tests.ResourceValidate.run
+  Tests.ContractTransport.run
+  Tests.ContractPipeline.run
+  Tests.ContractDecompile.run
+  Tests.ClaimsV3.run
+  let result ← LSpec.lspecIO (.ofList [
+    ("v3 catalogs", Tests.Ix.Catalog.suite),
+    ("primitive addresses", Tests.Ix.Kernel.PrimAddrs.suite),
+    ("source contracts", Tests.Ix.SourceContract.suite ++
+      Tests.Ix.SourceContract.Driver.suite)]) []
+  unless result == 0 do throw <| IO.userError "primitive or source contract regression"
+  if args.contains "--primitives" then
+    let bytes ← IO.FS.readBinFile "/tmp/ixon-v3-primitives.ixe"
+    let env ← IO.ofExcept (Ixon.runGetExact Ixon.Env.getEnv bytes)
+    IO.println s!"Validating {env.consts.size} constants from the primitive closure"
+    let resolved ← IO.ofExcept (Ix.Resource.validate env (Ix.Resource.standardProfile env))
+    IO.println s!"Validated {resolved.addresses.size} addressed interfaces"
diff --git a/Tests/IxonV3Primitives.lean b/Tests/IxonV3Primitives.lean
new file mode 100644
index 000000000..48676c282
--- /dev/null
+++ b/Tests/IxonV3Primitives.lean
@@ -0,0 +1,22 @@
+import Tests.Ix.Kernel.BuildPrimitives
+
+open Tests.Ix.Kernel.BuildPrimitives
+
+def main : IO Unit := do
+  let leanEnv ← get_env!
+  let needed := collectDeps leanEnv (kernelPrimitives.map parseNameToLean)
+  let constants := leanEnv.constants.toList.filter fun (name, _) => needed.contains name
+  IO.println s!"Compiling {constants.length} primitive dependency declarations"
+  let raw ← Ix.CompileM.rsCompileEnvFFI constants
+  let env := raw.toEnv
+  let mut text := "# Ixon v3 canonical primitive addresses\n"
+  for name in kernelPrimitives do
+    let some named := env.named[parseIxName name]?
+      | throw <| IO.userError s!"missing primitive {name}"
+    text := text ++ s!"{name}\t{named.addr}\n"
+  IO.FS.writeFile "/tmp/ixon-v3-primitives.tsv" text
+  let bytes ← match Ixon.serEnv env with
+    | .ok bytes => pure bytes
+    | .error error => throw <| IO.userError error
+  IO.FS.writeBinFile "/tmp/ixon-v3-primitives.ixe" bytes
+  IO.println s!"Exported {kernelPrimitives.size} primitive addresses and {env.consts.size} constants"
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 352efcb34..a33b64044 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -33,6 +33,10 @@ import Tests.Ix.Kernel.PrimAddrs
 import Tests.Ix.RustSerialize
 import Tests.Ix.RustDecompile
 import Tests.Ix.Sharing
+import Tests.Ix.SourceContract
+import Tests.Ix.SourceContract.ImportCheck
+import Tests.Ix.SourceContract.SyntaxCheck
+import Tests.Ix.SourceContract.Driver
 import Tests.Ix.BenchMeasures
 import Tests.Ix.Tc.Unit
 import Tests.Ix.Tc.Substrate
@@ -95,6 +99,7 @@ def primarySuites : Std.HashMap String (List LSpec.TestSeq) := .ofList [
   ("canon", [Tests.CanonM.suite]),
   ("keccak", Tests.Keccak.suite),
   ("sharing", Tests.Sharing.suite),
+  ("source-contract", Tests.Ix.SourceContract.suite ++ Tests.Ix.SourceContract.Driver.suite),
   ("graph-unit", Tests.Ix.GraphM.suite),
   ("condense-unit", Tests.Ix.CondenseM.suite),
   ("bench-measures", Tests.Ix.BenchMeasures.suite),
@@ -228,22 +233,22 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
     match AiurTestEnv.build IxVM.ixVM IxVM.functionGroups, AiurTestEnv.build IxVM.ixVMFull with
     | .error e, _ | _, .error e =>
       IO.eprintln s!"IxVM env build failed: {e}"; return 1
-    | .ok v2Env, .ok v2FullEnv =>
+    | .ok vmEnv, .ok fullVmEnv =>
       -- Kernel-arena fixtures: the repo's NEGATIVE corpus (every
       -- `bad_*` must be rejected by an in-kernel assert_eq!). Runs
       -- through the kernel's subject-only `verify_const` debug
       -- entrypoint, which lives only in the FULL toplevel — the
       -- production one carries `verify_claim` alone.
-      let arenaSeq ← Tests.Ix.Kernel.Arena.arenaTests env v2FullEnv.compiled
+      let arenaSeq ← Tests.Ix.Kernel.Arena.arenaTests env fullVmEnv.compiled
       -- Adversarial Ixon: exploit attempts authored as raw Ixon
       -- constants, below the layer the arena's Lean fixtures can
       -- reach. Each case pins the kernel's verdict, which is REJECT
       -- except where accepting is the specified claim semantics.
-      let exploitSeq ← Tests.Ix.IxVM.Exploits.exploitTests env v2Env.compiled
+      let exploitSeq ← Tests.Ix.IxVM.Exploits.exploitTests env vmEnv.compiled
       let aiurSeq := (kernelChecks ++
           [envFull, envFrontier, checkAsm,
            revealFields, revealExpr, revealModes, revealCPrj, containsTc]).foldl
-        (init := .done) fun s tc => s ++ v2Env.runTestCase tc
+        (init := .done) fun s tc => s ++ vmEnv.runTestCase tc
       -- Codegen parity gate: the generated Rust kernel is emitted from
       -- the toplevel, so this runs the same witnesses through both
       -- engines and asserts they agree. It is only meaningful against a
@@ -252,9 +257,9 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
       -- `kernelChecks` cases (`runParityCase` ignores the FFT pins), so
       -- the per-constant witness setup runs once, not twice.
       let paritySeq := kernelChecks.foldl (init := .done) fun s tc =>
-        s ++ runParityCase v2Env.compiled tc
+        s ++ runParityCase vmEnv.compiled tc
       let fullSeq := [kernelUnitTests, serdeTest].foldl (init := .done)
-        fun s tc => s ++ v2FullEnv.runTestCase tc
+        fun s tc => s ++ fullVmEnv.runTestCase tc
       -- Shard pipeline: witness built in Rust (thin-frontier claim,
       -- parallel closure walk) and run on the native kernel. Pinned FFT
       -- is the regression signal.
@@ -264,8 +269,8 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
         -- constants throws instead of skipping.
         | none => pure (LSpec.test "shard pipeline: SKIP (target absent)" true)
         | some (handle, ownedBlob) =>
-          let funIdx := v2Env.compiled.getFuncIdx `verify_claim |>.get!
-          match v2Env.compiled.bytecode.shardCheckWithEnv
+          let funIdx := vmEnv.compiled.getFuncIdx `verify_claim |>.get!
+          match vmEnv.compiled.bytecode.shardCheckWithEnv
                   funIdx handle ownedBlob false with
           | .error e =>
             pure (LSpec.test s!"shard pipeline execution: {e}" false)
@@ -274,10 +279,10 @@ def ignoredRunners (env : Lean.Environment) : List (String × IO UInt32) := [
             -- (`.round.toUInt64.toNat`): any cost shift must be an
             -- explicit, reviewed bump.
             let actual :=
-              (Aiur.computeStats v2Env.compiled qc v2Env.shapes).totalFftCost.round.toUInt64.toNat
+              (Aiur.computeStats vmEnv.compiled qc vmEnv.shapes).totalFftCost.round.toUInt64.toNat
             pure (LSpec.test
-              s!"Shard pipeline FFT matches: expected 6_999_296_124, got {actual}"
-              (actual = 6_999_296_124))
+              s!"Shard pipeline FFT matches: expected 7_072_190_269, got {actual}"
+              (actual = 7_072_190_269))
       LSpec.lspecIO
         (.ofList [("ixvm",
           [fullSeq, aiurSeq, arenaSeq, exploitSeq, paritySeq, shardSeq])]) []),
diff --git a/Tests/SourceContractMain.lean b/Tests/SourceContractMain.lean
new file mode 100644
index 000000000..8c786eba1
--- /dev/null
+++ b/Tests/SourceContractMain.lean
@@ -0,0 +1,8 @@
+import Tests.Ix.SourceContract
+import Tests.Ix.SourceContract.ImportCheck
+import Tests.Ix.SourceContract.SyntaxCheck
+import Tests.Ix.SourceContract.Driver
+
+def main (args : List String) : IO UInt32 :=
+  LSpec.lspecIO (.ofList [("source-contract",
+    Tests.Ix.SourceContract.suite ++ Tests.Ix.SourceContract.Driver.suite)]) args
diff --git a/crates/common/src/prim_addrs.rs b/crates/common/src/prim_addrs.rs
index 661dc145e..5b5e40729 100644
--- a/crates/common/src/prim_addrs.rs
+++ b/crates/common/src/prim_addrs.rs
@@ -146,61 +146,61 @@ impl PrimAddrs {
     };
     PrimAddrs {
       nat: h(
-        "1dfffde48c4ef6653b95ecc5474dee8b99461008d26d80ca384f1e59e927714d",
+        "35e1cc809f6f076521a43f85068d5592220407c0532b6a08952f40d8523d04bc",
       ),
       nat_zero: h(
-        "50e5d69d806bc1c616cace4230c982a0ee5b350b3efe3b1a15801df77fc00c8c",
+        "eeb2e6268ff6d0e6b2e9764d9940b81bb64b9f8f4b1358d294ff9817e6941a46",
       ),
       nat_succ: h(
-        "8c09ca644b10decad158d37006e81cdc1b84761312260546449aa02e343b2b0c",
+        "42d6ed31536f0958176f1dc973383808ac8583223746ebca78dbe389b65321a6",
       ),
       nat_add: h(
-        "f9ac92a11388a7cdca229a8024208554feb32d6c0a3af74a7bc12c28b949543c",
+        "724db797e1817545a08371432fd1fa6428a37dcf9c1671df7e464849db0a81ac",
       ),
       nat_pred: h(
-        "fce916cf3c6dd01ad8c6d38641bca7b3eeac5bc93b3529ad7812768b3407d64e",
+        "76afa254a8bbf2ac4327d7b94be0c63bd708836b5f7384ce990388adb0a1d3cf",
       ),
       nat_sub: h(
-        "df38352ffa1d6e292349259f33eb678024bb646b358638a02da1995ed4abeb09",
+        "9de2d2c60e7d421a2fdfb8706e91e0e6d8576c3bd46ec00405c65875cb9b5a26",
       ),
       nat_mul: h(
-        "f38d4f7baaa021e3b555312145d9ffd3ddc5eacb7bfd5b86a7b0eafdfcf416aa",
+        "566a3c2249bc2076543d9bc561a841f6fd35ffb5bdbbc5c991a9c64feccbd5d4",
       ),
       nat_pow: h(
-        "68f61ef55b63cd23ad8ed185b7eec3dc754e61cc58056087a97e819d0e95e6fd",
+        "5ba43ac3e5d29fe5ce81f18a18178a2705c37ee674b9b6ee50e9466a86593b15",
       ),
       nat_gcd: h(
-        "ad47f2bbe891b825c48a278f9a0d72997b78baac79891ca6651988b7c9b47f03",
+        "76007dcf8b285cdbd6f779012290fe2e6afd221ce8821082a7e2ef81e8d815cf",
       ),
       nat_mod: h(
-        "f6eb742996c60f1068c2d437afdd8b3609040d64eec5e15f07a11dc11d070d7b",
+        "e6ffe78713d4b974a82d0187538f1a0cf5c4b260f0fd99264fab263b1af847f9",
       ),
       nat_div: h(
-        "23173649a58ea5095d1c51a21c7ad2cf8e8dccef342698e07e241668ff7ad3e7",
+        "c075ed976f1702f364fb0bb34aa8bbc166adace573f2ce914b43dc4f4aab6219",
       ),
       nat_bitwise: h(
-        "85a6fefff63e96a963ef8406d394ab39992323a0ff4530e134a94d46e3a7ba4d",
+        "aaf7df6a1f024f580fde236cba16235f071d1b796cc279faf43178d22b5ae36d",
       ),
       nat_beq: h(
-        "72c6d4a3b653798850a9ed57018b87ceee0e34195c0902858fd41f6f0e9962ae",
+        "ffd3f02a19fda649aa5608ed818db382e160231b76d5b09176d7dd1a8d5b1ec5",
       ),
       nat_ble: h(
-        "c37f2e811f44d59c07094947146ffcbd3aec5ec7002ac3c48ebdebcd83d4688e",
+        "68a3643ec69816aec107302ddbfa054cebcd3ec173cd5f7e6d883638631afe65",
       ),
       nat_land: h(
-        "8f475cc72da2ac6ce2a9282b6b5df4ccf7bc3cee0649d22766bebd32d1806f3b",
+        "c61fad46a102dbff5922312d4fbe6e704ec3c62c6c6f64b3d481b78c77cf315d",
       ),
       nat_lor: h(
-        "8f3c1c432c598e4240d36f8945942174675c5c91e03f6b8ab018e8b052622c63",
+        "cb7dccc020a530fed7c622b100ee52c1078b5018159ba4682f817e3776789ee8",
       ),
       nat_xor: h(
-        "800a8a2d6f91bd1a91d313d1e19ef69f37dedd07f7de4f929780be855a03fd1f",
+        "d8a6b05a1a4e5cadc69c53792e8e130314745e76e32bb30a9ce0272fa079e8a6",
       ),
       nat_shift_left: h(
-        "5473592e707943ec072a2ee53c433da2c77aa45ed634da54b24374d19eb90cd2",
+        "5c15f98e2bd9c257bcdfac62b0043a2e3e2bbdff8b210f104b5c3739e862ac0c",
       ),
       nat_shift_right: h(
-        "1b591149158d896937eebfd53232b5ae8a4bcdb25a6811c96bd94114a9f8bed5",
+        "3f92725324b09fa75c6fcd16da863671428ff33b7db667eb760e1cd503a2bcad",
       ),
       bool_type: h(
         "e6eba3c8b4d19f6a1076b39fa89aec61dccbb960f83d9a62e6acf35a69c9a0a4",
@@ -212,63 +212,63 @@ impl PrimAddrs {
         "dda12bcb330727f6dfb816bc9752aabd0520e6515b79fc8a5a9e713866f4c63e",
       ),
       string: h(
-        "4288f92ed1d51f4935e5d2775f33ec585d6fe5ec63dadf0ea698554478fd9fad",
+        "9d6ae43429ec02a9338bbcd0db0ac193d75ebd46f884bfcbd2c42bf7faea150d",
       ),
       string_mk: h(
-        "d54db71fee55311aafeead74768e6e952262c29abd24b9319fa6859481dd44b8",
+        "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2",
       ),
       char_type: h(
-        "d55429725a19c1837b34624fb35784b91bc8b0e2d79f98b3c296317fb6c5c789",
+        "4c59bc4eac82d31ebed59bb206909dbded65b92fd56de2518fcdadb0a42c11a0",
       ),
       char_mk: h(
-        "7b443f2f10fd4b2fb88b59e90f1a04b46552f73ea2e8f26d77290b7ae63dd531",
+        "82e09601422cae23b0b6df9922abb9f0b014e20047a00a7ab96871dd7da3e5ac",
       ),
       char_of_nat: h(
-        "29563da271c23f66b27d05f924fb0612272dcfba6b1083b348733e00f9b36b2a",
+        "caf51b039d71cfce7063e106064f9435f5337bbc42567c8c78b5f66c7f087920",
       ),
       // NOTE: `String.ofList` and `String.mk` share the canonical content-hash
       // because both compile to the same Ixon form (a one-constructor `String`
       // built from `List Char`). The Lean-side deprecation of `String.mk` in
       // favor of `String.ofList` is orthogonal to the compiled representation.
       string_of_list: h(
-        "d54db71fee55311aafeead74768e6e952262c29abd24b9319fa6859481dd44b8",
+        "272ea5ce6bab8958165c7f56d71ffe2a5b175ed58110126dfa96e1f8a0c99ad2",
       ),
       string_to_byte_array: h(
-        "ad700c0806e673e74adcafc28ca659d30a616633a4a36420324fc29eae69eb9c",
+        "79862acfbc2e37b7b6122143f0a6a51114c34fa483ff14146483de18835d4209",
       ),
       byte_array_empty: h(
-        "d838bb6bb651533081ac2495a25d690c54f8e345fff41efbd5585eb468705308",
+        "bf58e6cb3aa0f746850629041635cd30c0ad66262b6617660f2290241f08b08b",
       ),
       list: h(
-        "ae8d736dd3fcc89dc3f9d66aa54bed4ad8607fb9d4843f4c8736591dd0c9e000",
+        "4fb6b41c30532e6ab4acb4eefe01da1314ee7f2129af8989fd63f7ec277aaf01",
       ),
       list_nil: h(
-        "3c0149c3432969ee5d9354c8d2d89ceec4a79711f8dec8710879a12a12b72c42",
+        "3994bc51e3686f30a1d483d69d0a835a7b484d892393c084f87a5849de54f302",
       ),
       list_cons: h(
-        "d1e0802c38bcda14061e2012f12e73c2a24a671137984f8ef76744ea04d188c4",
+        "b3a7d80249fd823100ee03626232d1412a0e8335275d5df53b92943887b650f7",
       ),
-      eq: h("b20ea17ba3d9723f0bd06457d9cf48ce26ca36619b946980627de923873e9595"),
+      eq: h("c37d6290e00fb865fb5db7bce18fd69e6d1674ad573724b85466ea9f7578a207"),
       eq_refl: h(
-        "e308035bdf280c927556824d6a9f9236a1487651f0059a7df3bda85b331f67e6",
+        "d494dc601386ba8e8f0b711fe62a2d60ab60c6488c8cf6ce97796ebc3ad5fefb",
       ),
       quot_type: h(
-        "e775aa31759a9d4acdbc2b8519ff73f57552bb0cba4daf1659bba00f6a931b4b",
+        "45040b3126855169dad919a970a9c72cee5875658aedb3bd1f89fcdf8c88edfa",
       ),
       quot_ctor: h(
-        "0a4cc7c930dd6726bbd7f1bc3fea685df5f666549d651d3e766fe5746ec459a4",
+        "811600dfa59f3612cb03c0f0475af152399defff9226c6e19fd648041a6899a9",
       ),
       quot_lift: h(
-        "560276f95e0d93e27b8c05097995bf82876332c2e7e31033e0a194819e4e8d30",
+        "86b365e75bb4230f04c6e4f3a7ca6988adf574616d79a3d7477ad65cac102110",
       ),
       quot_ind: h(
-        "02f358808fd4328d74850582d3608d2d31e49519b4c6c66b3605fbe6f42d3c5d",
+        "1745491c0d651de0bea589d5fffbc9bc4d7fbe897c1d805b1f7f59ca9696a6ef",
       ),
       reduce_bool: h(
-        "d4d775ceff37ab7a402416118f1d2ce5b9e7f2143d0c3dc8fe5431571df3260c",
+        "bacc4c814a4572ddfd969a1857adfe18239eb6bd8b1627ee79744a6a9b23b030",
       ),
       reduce_nat: h(
-        "2075bda5457b299b27246770c8416273686bbf627aa6a01ac413a27e583eb95d",
+        "b6327d9a1bbb461a447f0c971e622dd9a35132bd7de75bf69e20794d7a0e8595",
       ),
       // Synthetic kernel-only marker. This is intentionally not the compiled
       // Lean content hash: `eagerReduce` canonicalizes to the same content
@@ -278,161 +278,161 @@ impl PrimAddrs {
         "ff00000000000000000000000000000000000000000000000000000000000003",
       ),
       system_platform_num_bits: h(
-        "5060a22df86307dd8bbe656e13868f3a1618e7a0d880b8cbb00759cffd31800d",
+        "6f620654d341990a301387b80ef75b1e0b6130ddf19164025b6dc37bf3c3dc18",
       ),
       system_platform_get_num_bits: h(
-        "80f975ded9d6ab7095e9db2ed1cfa6f5c35eafe5c56990e2c1321b02c5664e6c",
+        "00c266834f9039931b4be2fac5584cd176a0ae7ee4cb4064ddb5e04dd12b6cbb",
       ),
       subtype_val: h(
-        "7e4e9b33b696a7d3fce1745dfb5fbeeb938fc8882a82bee15723e0d253e59158",
+        "ea65f517457fae9b705299da08b0d3c8cf9a476f16470cca5cae5ea7bd238230",
       ),
       nat_dec_le: h(
-        "2999801598c1da48f562d4836064f635c045d0521452b5e74a12bf99d2e316ec",
+        "f0f15ed079822f06e82e36664bf61e797e5b1e7b0b4155152762c513274bfee1",
       ),
       nat_dec_eq: h(
-        "1bac041756ed22d73bbcac849a94f246ee2696999faf351940468d962970ca2a",
+        "8a5d5eee414a2fa5956b74e8323a20508d774ed1b5603f55e774ad896bd3e6e7",
       ),
       nat_dec_lt: h(
-        "12f386f486913b11b5473cb2538330d51f25aeec7f2d7d6b96904329c78b6967",
+        "7c4977196e95be2a759fc9c6d1533db8da49592f06419b155d888333c8dd8931",
       ),
       decidable_rec: h(
-        "6af73809a6128adcb9c5d7e73a30c28d489dba4d905717055ac2edd755ffa713",
+        "16cfddda9c274660f391b10eefe066275afffae1ccd49c6daf43afb8a80aea85",
       ),
       decidable_is_true: h(
-        "7b3f6a6eebf32a9d5a54305e693dce60511afeb1fa11bc8844a5c21bbfd3214c",
+        "363d071182be414e1a58599b83f5e19f9b873723054f4287ba69705aafef27da",
       ),
       decidable_is_false: h(
-        "ab1470196419f71d06feed9ccb8c1d03674528ec03012b095badc169d48d03d0",
+        "8cc0e1360c1b29108dab3d6172e7fce8a9aa9640daa4bbe99ba1305d9623624b",
       ),
       nat_le_of_ble_eq_true: h(
-        "23bea3bbf3a8d0a8d0033cf7e56af0c4aee01582d5a758c0df5615929ca6204d",
+        "ad25bfd207bae832c73d5ce614bead22ef9862e110f8d17a5064ffb7603eee3d",
       ),
       nat_not_le_of_not_ble_eq_true: h(
-        "be50b6053df0b07438a4ac2eefd70a11708b0cbb0fc90564bafee6e165615de8",
+        "e3658f50dc5123efff213588dee3d4c6063f5edb18950850ac0490c937819009",
       ),
       nat_eq_of_beq_eq_true: h(
-        "c489329197b59a040d1e5e4d5de6a770478d1ea4f9750176026dd2bf8593bf22",
+        "9c91e79de732226ba2e73cbdd330851baec40668eb40c6f32aa2f8dac5a04b51",
       ),
       nat_ne_of_beq_eq_false: h(
-        "0eb5b987f12124be0575a477cc0a535516a24b0ae5ceddbee2d472765aed299c",
+        "a07db532747e65ee77a7ba015069bdbaf1f709ce0d60b83c94f40d0e5e57595a",
       ),
       fin: h(
-        "a7e9a8b84a2fe96cc204acc93d7ed1366d9d0574aaf0f09633d2b09a94c9e860",
+        "3d79797bc572d8f33eb7cff5aa13f8dc73bcf21026bf05d03888c9aa0369dcef",
       ),
       bool_no_confusion: h(
-        "99e7eaac2b27ffae4adc4902f8965520ee696c662438f10169cf36c8ad4cc4e5",
+        "de7b523cc4470e15328a01d935988861dadf9bd012240400464dea8c79a9dfe2",
       ),
       // Int primitives — canonical content-hashes from
       // `lake test -- rust-kernel-build-primitives`.
       int: h(
-        "fb2bd9d8fb7c3cc603bc021dcdbc5c6aa3ae80688b7d2e85ab18fa336ccc04ba",
+        "c60c95e3cdbf4ed010d999b3277f4e1fd3695e8c30260876102905d7b36241a2",
       ),
       int_of_nat: h(
-        "48786b7f7adc632ae35059f3fd181df32d9e5cc7360c4fd02c3e8b1181a1539b",
+        "0a99f49cc73ab9f42783092e7120613225670bab89b9d63533d1adefc876182f",
       ),
       int_neg_succ: h(
-        "cfc934fd6d53a5b23b6a3b30d02165fdaa574e3b5eb13926bb166e6486fc0e50",
+        "f7130d5864e1ba77b0f6a7338f92159c35bd5147e0febcf1ebed456e513538cc",
       ),
       int_add: h(
-        "1e60bd377a746cb7bd7ae541d7dfb237097d883d28ec7aadd732c0674e0db964",
+        "9db0177e4e8b6a0e7323069509c2457de9598a7e38e72ffe19ad34617256e10d",
       ),
       int_sub: h(
-        "0d74ba85f9749a0c25aa6a2b70348e57e709831fb7cc05229fecd7d66adf184d",
+        "85621387ef3027028d835287f3cc1461ef041def1fd91e28e87f669cc04a5eea",
       ),
       int_mul: h(
-        "c5bef6be6c3fdc520454c11e9950eb2f1a6c92f41a646b5ca168ff198f13c55a",
+        "b05459623d23299d3a849eb7fb75badbc1547a1cd9ee560c15067fbd985c6cea",
       ),
       int_neg: h(
-        "bc61c10fcca6415223ed97bcae21cb99d4836d077b0786a2fc5c5905f8b04ba2",
+        "6701d765ff10bfa3a6c347df15194e0db862ee25b54f25a59f7cf21951a3997e",
       ),
       int_emod: h(
-        "d435a15e6f222f786b6130fa764c7fbe98746f798e97a627a6237a17e74f7227",
+        "e29cfa7921bb57f4782b021c977596a4fae04e94f7b07955fe2814fc48de90e7",
       ),
       int_ediv: h(
-        "3e13fc1a077eb692af40acbed4a6adae255c0cbbba9a3c1f0de29573b197cb0e",
+        "9c952d45a3bd43161529fcfb5e276beab0cf4fd64a01ba9bc2c7cda376cb8f54",
       ),
       int_bmod: h(
-        "9970f402c870e8a3146fbf4b76f949aa64b206de9b0157b469fde357b715f19c",
+        "0b1564dea6ffcd204ebcd1aa69d29ee6f3acccd87bd146ff674556ac9cc8ccb3",
       ),
       int_bdiv: h(
-        "867f8e9dfb752265ba4742368b6afa546ae4e240fc5ac69b4a4e86d85a6e46f6",
+        "6d35dc43660f6c509a13f2824c027ed99ab070a08f058ff0a5f46a759250797d",
       ),
       int_nat_abs: h(
-        "21d4dacc0f406b31e044fbf4d8987a332dd8b4244f7d9e62b086501474825544",
+        "261ae54edb66e900784a64350bc01e8b3fe1332a47caeab58e0361dffc7ea008",
       ),
       int_pow: h(
-        "878599e9f5bbccb942232ff93b62c63db4ebdf62b9f9237900a37049f422ad86",
+        "87266415982bbdec50c61dec5b73cc0ccd5c997445997a9724a1cc5c2e39d3a4",
       ),
       int_dec_eq: h(
-        "7a06496d07b59710348a5f657851a4eea1f59492a5b7de3f51abbc84f9bc1d17",
+        "fc8c44cc970cfc183ccd10a2d1cdeb2c849307760e91f5cd29a2b02f706d83da",
       ),
       int_dec_le: h(
-        "14eccee1deba05e9443bd169d00ed634170e3246b37921199edbbad3f67db5b4",
+        "fcdf1860ad4cd672239392e60e7b49e024af0475739c3a40195a914eaec42c04",
       ),
       int_dec_lt: h(
-        "ad32c05d7e3c5ddf4e4c85cf8f60d83e0fba55e2676bf8a1e608db54b167c9fa",
+        "1d54806ab1ebc791e1db96e88d0407cef3523927d60ba669689b92a8eeb36445",
       ),
       punit: h(
         "2dfc16af01b82b3b91c2ff704409d76236a83f956c0c6e6659a64fe21d76695b",
       ),
       pprod: h(
-        "7eac420873e8f1ea8fe66831a6c6f69d88693bed6aeb30bfba82069af60ebea8",
+        "90ca5bcf995d68d7dfcb3c7cfe466986dc4beaa402b262ca395b3e53c36f6cad",
       ),
       pprod_mk: h(
-        "f3993d287c47b81c9e0902aa91d227650f6f4e55b3a1c63a87f283b4ed9e418e",
+        "ce30fc0f4135e679cf3b16d0d667bd9df4e7a69dbb8177a29e5c75b48c4cec10",
       ),
       // Names previously matched via `is_const_named` in whnf.rs.
       // Canonical content-hashes from `lake test -- rust-kernel-build-primitives`.
       nat_rec: h(
-        "89d6690b0808b1da49e015a4f21df3fc3f00fb96ac502f5f097ce452e573704c",
+        "d1053449c217e5cc6fc29b2cb59cfd5ead385d392d00ada2221d4000dda7def3",
       ),
       nat_cases_on: h(
-        "b2f8855b5e76a480493cd6cc922977e60723b4bec665dd7e9b73ca2b215df576",
+        "c575abb02efd158091356aa793c809c0570f8a24a8a777f206a95b9ce0b88855",
       ),
       bit_vec: h(
-        "c7192ac507d67c3c3e1eb90633858ae7b7cbc80e3988312618c7ec09b483b04a",
+        "7f0f5feda1828072123f242a46a40549e85934f7395e4f93f65dda4e4809f325",
       ),
       bit_vec_to_nat: h(
-        "acd9f0a3f7e8c53a46b91759358366fa028240b0b6cc09205dde34a33544678d",
+        "c110d614b441c6cca69ecd7c1c2c76f3bc21fd40c4001e6a1a7d1cf481e23cdd",
       ),
       bit_vec_of_nat: h(
-        "5721ca2acf2c6994771509332fb185f783f442aefce417d2863e2d148edcdb8a",
+        "29b9f24086b1b1f88211358866139fdb7dcdfc97b5f6c77fc495bf8c77639982",
       ),
       bit_vec_ult: h(
-        "8d57c7c6aee1ba510d3208ddc4b08a83b44319f6af8ee09b3940d0ddedce1eb6",
+        "9301d850bde246940b7b3e81e786f7f12bae8e5cea6b3f4040060b3a7f59557c",
       ),
       decidable_decide: h(
-        "d1107c99ad9ebcb5028d9aea0da521ed5c12e71ea2ecdeaf637bb4a14d4a7e44",
+        "20e8906280b4dcd74a7a78e06d580e6f00eebba9fc40789262e95cacb6f0d699",
       ),
       lt_lt: h(
-        "c69df4833ecdce76bdb0d23159e1fac652d88919768c312c6611dc060da16f04",
+        "4802b183f4d6dcccacba57721824a7bb67daeb2725da17239271c135952caa61",
       ),
       of_nat_of_nat: h(
-        "c68bfa47519ff72b1d053b86e6e3b7356286eb2252616cc5b2acbed59ef1f5f0",
+        "a99dedbb1676866aed829c3d4bba86a37e98ec62a35834389c32937e4e2b1a4a",
       ),
       unit: h(
         "9232498667f765f437dedaac828e555f6cc67a20e6db28f614fdf3c262710feb",
       ),
       punit_size_of_1: h(
-        "84fe3d0f08f0651a6f0936a9a0f18e4f0dace169ac4233bf1adad05d6e078a25",
+        "e85bf516c76cadd8ce1fdab3cc94ed685e47be3c7a8b52f53fe2b3502e6f70c7",
       ),
       size_of_size_of: h(
-        "78f38887f6bbe54339ecec6b3c5f66856de7baa530378d2d9065bfe2daf4b801",
+        "402b71bcccf0be0315f1bda6bdbb20e559e31704617d3eaccb05d5c5fe03b53d",
       ),
       string_back: h(
-        "3f92a46a1451fd66215aae9cf789ce38a2c73fdd55909d454f61259634d90b6b",
+        "32104b03348d11acb2437fda24966dc58cc8c8bcca96582614e644d319a42c62",
       ),
       string_legacy_back: h(
-        "a2a310133d17371af67cd91d279aaf735fa8cb810c39aaa824a443c652e3df66",
+        "37ef5fee765dc2e5c7425c180cd42007db7d29ae0d5c091789f462f2805b0e09",
       ),
       string_utf8_byte_size: h(
-        "b1f6f04bde3d81f9102ea6b7d2c9f4236d72b17e01125523c5d5e261afc71105",
+        "52b0226ea14c94b1f9334c9957f5589399a86bcdae111f2847c9b0c2fb0a2261",
       ),
       string_append: h(
-        "b6ec2d443f3ee61de45ad859b8cc41a896d8fba49bc29883fc34c427dbdf71f8",
+        "132f1175cc3cac5a3e3d74e8797f9ba67f2e467b8004a3f28bb5dfd16a3647b1",
       ),
       string_dec_eq: h(
-        "d616327d4fc219bd7114bad46cd0866befe2551518b5bf2e10b5cac93381fb77",
+        "19134fdc188e8377d0173857e15d3b5065ed76da981397107e5c404db3f3b718",
       ),
     }
   }
diff --git a/crates/compile/src/compile.rs b/crates/compile/src/compile.rs
index facc04843..d4dc74ed6 100644
--- a/crates/compile/src/compile.rs
+++ b/crates/compile/src/compile.rs
@@ -912,6 +912,7 @@ pub fn compile_expr(
     BuildLet(Address, bool),
     BuildProj(u64, u64, Address), // type_ref_idx, field_idx, struct_name_addr
     WrapMdata(Vec<KVMap>),
+    ApplyContract(crate::semantic_contract::Contract, LeanExpr),
     Cache(LeanExpr),
     /// Build a surgered call-site from compiled head + canonical args + collapsed args.
     BuildCallSite {
@@ -1755,6 +1756,12 @@ pub fn compile_expr(
           },
 
           ExprData::Mdata(kv, inner, _) => {
+            if crate::semantic_contract::has_metadata(kv) {
+              let contract = crate::semantic_contract::read(kv)?;
+              stack.push(Frame::ApplyContract(contract, inner.clone()));
+              stack.push(Frame::Compile(inner.clone()));
+              continue;
+            }
             // Compile KV map
             let mut pairs = Vec::new();
             for (k, v) in kv {
@@ -1852,6 +1859,11 @@ pub fn compile_expr(
         }));
       },
 
+      Frame::ApplyContract(contract, source) => {
+        let inner = results.pop().expect("ApplyContract missing expression");
+        results.push(contract.lower(&source, &inner)?);
+      },
+
       Frame::WrapMdata(mdata) => {
         // Mdata doesn't change the Ixon expression — only wraps the arena node
         let inner_root =
@@ -2151,6 +2163,7 @@ fn audit_plan_head_arities(
     return Ok(0);
   }
 
+  let annotated = crate::semantic_contract::inspect(top)?;
   // `obscured` means this expression occurs in the function part of an outer
   // App whose telescope stopped at a non-App wrapper.  A short plan spine in
   // that position cannot be assigned a local source-order interface safely.
@@ -2173,6 +2186,15 @@ fn audit_plan_head_arities(
         let (head, args) = surgery::collect_lean_telescope(&e);
         match head.as_data() {
           ExprData::Const(name, _, _) => {
+            if annotated && plan_head_arity(stt, name).is_some() {
+              return Err(CompileError::UnsupportedExpr {
+                desc: format!(
+                  "resource contracts across non-identity call-site surgery: {} calls {}",
+                  owner.pretty(),
+                  name.pretty()
+                ),
+              });
+            }
             if let Some(arity) = plan_head_arity(stt, name)
               && args.len()
                 < if arity.head_rewrite { arity.expected } else { arity.floor }
@@ -2206,6 +2228,15 @@ fn audit_plan_head_arities(
         }
       },
       ExprData::Const(name, _, _) => {
+        if annotated && plan_head_arity(stt, name).is_some() {
+          return Err(CompileError::UnsupportedExpr {
+            desc: format!(
+              "resource contracts across non-identity call-site surgery: {} calls {}",
+              owner.pretty(),
+              name.pretty()
+            ),
+          });
+        }
         if let Some(arity) = plan_head_arity(stt, name)
           && (obscured || arity.head_rewrite)
         {
@@ -3320,14 +3351,36 @@ pub fn compare_expr(
     (ExprData::Fvar(..), _) | (_, ExprData::Fvar(..)) => {
       Err(CompileError::UnsupportedExpr { desc: "fvar in comparison".into() })
     },
-    (ExprData::Mdata(_, x, _), ExprData::Mdata(_, y, _)) => {
-      compare_expr(x, y, mut_ctx, x_lvls, y_lvls, stt)
+    (ExprData::Mdata(dx, xi, _), ExprData::Mdata(dy, yi, _)) => {
+      if crate::semantic_contract::has_metadata(dx) {
+        if crate::semantic_contract::has_metadata(dy) {
+          let cx = crate::semantic_contract::read(dx)?;
+          let cy = crate::semantic_contract::read(dy)?;
+          let order = SOrd::cmp(&cx.order_key(), &cy.order_key());
+          if order.ordering != Ordering::Equal {
+            return Ok(order);
+          }
+          compare_expr(xi, yi, mut_ctx, x_lvls, y_lvls, stt)
+        } else {
+          compare_expr(x, yi, mut_ctx, x_lvls, y_lvls, stt)
+        }
+      } else {
+        compare_expr(xi, y, mut_ctx, x_lvls, y_lvls, stt)
+      }
     },
-    (ExprData::Mdata(_, x, _), _) => {
-      compare_expr(x, y, mut_ctx, x_lvls, y_lvls, stt)
+    (ExprData::Mdata(data, inner, _), _) => {
+      if crate::semantic_contract::has_metadata(data) {
+        Ok(SOrd::gt(true))
+      } else {
+        compare_expr(inner, y, mut_ctx, x_lvls, y_lvls, stt)
+      }
     },
-    (_, ExprData::Mdata(_, y, _)) => {
-      compare_expr(x, y, mut_ctx, x_lvls, y_lvls, stt)
+    (_, ExprData::Mdata(data, inner, _)) => {
+      if crate::semantic_contract::has_metadata(data) {
+        Ok(SOrd::lt(true))
+      } else {
+        compare_expr(x, inner, mut_ctx, x_lvls, y_lvls, stt)
+      }
     },
     (ExprData::Bvar(x, _), ExprData::Bvar(y, _)) => Ok(SOrd::cmp(x, y)),
     (ExprData::Bvar(..), _) => Ok(SOrd::lt(true)),
@@ -4902,7 +4955,9 @@ pub mod mutual;
 pub mod nat_conv;
 pub mod surgery;
 pub(crate) mod validation;
-pub use env::{compile_env, compile_env_with_options};
+pub use env::{
+  compile_env, compile_env_with_options, compile_env_with_profile,
+};
 
 #[cfg(test)]
 mod tests {
@@ -5058,7 +5113,8 @@ mod tests {
     let result =
       compile_expr(&expr, &[], &MutCtx::default(), &mut cache, &stt).unwrap();
     match result.as_ref() {
-      Expr::Lam(ixon::expr::Uses::Many, ty, body) => {
+      Expr::Lam(contract, ty, body) => {
+        assert_eq!(*contract, ixon::contract::BinderContract::default());
         match ty.as_ref() {
           Expr::Sort(idx) => {
             assert_eq!(*idx, 0);
diff --git a/crates/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs
index f0f7dd202..2f3146f09 100644
--- a/crates/compile/src/compile/env.rs
+++ b/crates/compile/src/compile/env.rs
@@ -145,14 +145,39 @@ pub fn compile_env(
 pub fn compile_env_with_options(
   lean_env: &Arc<LeanEnv>,
   options: CompileOptions,
+) -> Result<CompileState, CompileError> {
+  compile_env_with_profile(lean_env, options, None)
+}
+
+/// Compile semantic input with an explicit profile, or the built-in profile
+/// when omitted. No annotated result can bypass combined validation.
+pub fn compile_env_with_profile(
+  lean_env: &Arc<LeanEnv>,
+  options: CompileOptions,
+  profile: Option<&ixon::resource::addressed::Profile>,
 ) -> Result<CompileState, CompileError> {
   let _memory_sampler = crate::diag::memory_sampler("compile_env");
+  let mut semantic_sources = Vec::new();
+  for name in lean_env.keys() {
+    if let Some(c) = lean_env.get(name)
+      && crate::semantic_contract::inspect_constant(&c)?
+    {
+      semantic_sources.push(name.clone());
+    }
+  }
   let setup_start = Instant::now();
   // Whole-env scan: ref graph + immediate groundedness + inductive
   // groups in one decode per constant — the env decodes lazily, so
   // each additional full sweep would decode every constant again.
   let phase_start = Instant::now();
   let scan = setup_scan(lean_env.as_ref());
+  if let Some(name) =
+    scan.source_contracts.iter().min_by_key(|name| name.pretty())
+  {
+    return Err(CompileError::UnsupportedExpr {
+      desc: format!("unresolved source binder contracts: {}", name.pretty()),
+    });
+  }
   let graph = scan.graph;
   if *IX_VERBOSE {
     eprintln!(
@@ -1015,6 +1040,35 @@ pub fn compile_env_with_options(
 
   stt.finalize_hints();
 
+  if !semantic_sources.is_empty() || profile.is_some() {
+    if !stt.ungrounded.is_empty() {
+      return Err(CompileError::UnsupportedExpr {
+        desc: "resource compilation requires the complete requested closure"
+          .into(),
+      });
+    }
+    for source in &semantic_sources {
+      if stt.aux_gen_extra_names.contains(source) {
+        return Err(CompileError::UnsupportedExpr {
+          desc: format!(
+            "resource contract source was replaced by auxiliary generation: {}",
+            source.pretty()
+          ),
+        });
+      }
+    }
+    let default_profile;
+    let profile = match profile {
+      Some(profile) => profile,
+      None => {
+        default_profile = ix_kernel::resource::standard_profile(&stt.env);
+        &default_profile
+      },
+    };
+    ix_kernel::resource::validate(&stt.env, profile)
+      .map_err(|desc| CompileError::UnsupportedExpr { desc })?;
+  }
+
   if *IX_VERBOSE {
     let total_elapsed = compile_start.elapsed().as_secs_f64();
     eprintln!(
diff --git a/crates/compile/src/decompile.rs b/crates/compile/src/decompile.rs
index 652c71ad5..296034bbf 100644
--- a/crates/compile/src/decompile.rs
+++ b/crates/compile/src/decompile.rs
@@ -887,7 +887,14 @@ pub fn decompile_expr(
           arena_lookup(arena, current_idx, &cache.current_const)?
         {
           for kvm in mdata {
-            mdata_layers.push(decompile_kvmap(kvm, stt)?);
+            let data = decompile_kvmap(kvm, stt)?;
+            if crate::semantic_contract::has_metadata(&data) {
+              return Err(DecompileError::BadConstantFormat {
+                msg: "semantic contracts cannot come from optional metadata"
+                  .into(),
+              });
+            }
+            mdata_layers.push(data);
           }
           current_idx = *child;
         }
@@ -897,6 +904,20 @@ pub fn decompile_expr(
         // Push CacheResult frame
         stack.push(Frame::CacheResult(Arc::as_ptr(&e), idx));
 
+        if matches!(
+          node,
+          ExprMetaData::CallSite { .. } | ExprMetaData::EtaCallSite { .. }
+        ) && crate::semantic_contract::contains_ixon(&e, &cache.sharing)
+          .map_err(|msg| DecompileError::BadConstantFormat { msg })?
+        {
+          return Err(DecompileError::BadConstantFormat {
+            msg: "optional call-site replay would rewrite a semantic contract"
+              .into(),
+          });
+        }
+        if let Some(contract) = crate::semantic_contract::of_ixon(&e) {
+          mdata_layers.push(contract.metadata());
+        }
         match (node, e.as_ref()) {
           // Leaf nodes: Var, Sort, Nat, Str
           (_, Expr::Var(v)) => {
@@ -1410,14 +1431,22 @@ pub fn decompile_expr(
           ) => {
             // See Lam arm above: binder address must resolve.
             let let_name = decompile_name(name_addr, stt)?;
-            stack.push(Frame::BuildLet(let_name, *non_dep, mdata_layers));
+            stack.push(Frame::BuildLet(
+              let_name,
+              non_dep.non_dep,
+              mdata_layers,
+            ));
             stack.push(Frame::Decompile(body.clone(), children[2]));
             stack.push(Frame::Decompile(val.clone(), children[1]));
             stack.push(Frame::Decompile(ty.clone(), children[0]));
           },
 
           (_, Expr::Let(non_dep, ty, val, body)) => {
-            stack.push(Frame::BuildLet(Name::anon(), *non_dep, mdata_layers));
+            stack.push(Frame::BuildLet(
+              Name::anon(),
+              non_dep.non_dep,
+              mdata_layers,
+            ));
             stack.push(Frame::Decompile(body.clone(), u64::MAX));
             stack.push(Frame::Decompile(val.clone(), u64::MAX));
             stack.push(Frame::Decompile(ty.clone(), u64::MAX));
diff --git a/crates/compile/src/graph.rs b/crates/compile/src/graph.rs
index 4800f5ea1..d700ef69d 100644
--- a/crates/compile/src/graph.rs
+++ b/crates/compile/src/graph.rs
@@ -9,7 +9,7 @@ use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use rustc_hash::{FxHashMap, FxHashSet};
 use std::collections::hash_map::Entry;
 
-use ix_common::env::{ConstantInfo, Env, Expr, ExprData, Name};
+use ix_common::env::{ConstantInfo, Env, Expr, ExprData, Name, NameData};
 
 /// A set of [`Name`]s, used to represent the neighbors of a node in the reference graph.
 pub type NameSet = FxHashSet<Name>;
@@ -55,6 +55,8 @@ pub struct SetupScan {
   pub graph: RefGraph,
   pub immediate_ungrounded: FxHashMap<Name, crate::ground::GroundError>,
   pub ind_groups: FxHashMap<Name, Vec<Name>>,
+  /// Source contracts that the current conservative emitter cannot preserve.
+  pub source_contracts: Vec<Name>,
 }
 
 /// Fused whole-env setup pass: one decode per constant feeding the ref
@@ -75,6 +77,7 @@ pub fn setup_scan(env: &Env) -> SetupScan {
     in_refs: RefMap,
     ungrounded: FxHashMap<Name, crate::ground::GroundError>,
     ind_groups: FxHashMap<Name, Vec<Name>>,
+    source_contracts: Vec<Name>,
   }
 
   let names: Vec<&Name> = env.keys().collect();
@@ -84,7 +87,10 @@ pub fn setup_scan(env: &Env) -> SetupScan {
       let Some(constant) = env.get(name) else {
         return acc;
       };
-      let deps = get_constant_info_references(&constant);
+      let (deps, annotated) = inspect_constant_references(&constant);
+      if annotated {
+        acc.source_contracts.push(name.clone());
+      }
       // Keep an empty reverse-edge entry even for an isolated constant.
       // Missing referenced names also retain their incoming edges, as in
       // the reference graph used by ungroundedness propagation.
@@ -110,6 +116,7 @@ pub fn setup_scan(env: &Env) -> SetupScan {
       l.out_refs = merge_ref_maps(l.out_refs, r.out_refs);
       l.in_refs = merge_ref_maps(l.in_refs, r.in_refs);
       l.ungrounded.extend(r.ungrounded);
+      l.source_contracts.extend(r.source_contracts);
       for (k, v) in r.ind_groups {
         l.ind_groups.entry(k).or_insert(v);
       }
@@ -120,6 +127,7 @@ pub fn setup_scan(env: &Env) -> SetupScan {
     graph: RefGraph { out_refs: acc.out_refs, in_refs: acc.in_refs },
     immediate_ungrounded: acc.ungrounded,
     ind_groups: acc.ind_groups,
+    source_contracts: acc.source_contracts,
   }
 }
 
@@ -191,44 +199,80 @@ pub fn build_ref_graph(env: &Env) -> RefGraph {
 }
 
 pub fn get_constant_info_references(constant_info: &ConstantInfo) -> NameSet {
+  inspect_constant_references(constant_info).0
+}
+
+fn inspect_constant_references(
+  constant_info: &ConstantInfo,
+) -> (NameSet, bool) {
   let mut acc = NameSet::default();
   let mut visited: FxHashSet<&Expr> = FxHashSet::default();
+  let mut annotated = false;
   match constant_info {
     ConstantInfo::AxiomInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
     },
     ConstantInfo::DefnInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
-      collect_expr_references(&val.value, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |= collect_expr_references(&val.value, &mut visited, &mut acc);
     },
     ConstantInfo::ThmInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
-      collect_expr_references(&val.value, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |= collect_expr_references(&val.value, &mut visited, &mut acc);
     },
     ConstantInfo::OpaqueInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
-      collect_expr_references(&val.value, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |= collect_expr_references(&val.value, &mut visited, &mut acc);
     },
     ConstantInfo::QuotInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
     },
     ConstantInfo::InductInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
       acc.extend(val.ctors.iter().cloned());
     },
     ConstantInfo::CtorInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
       acc.insert(val.induct.clone());
     },
     ConstantInfo::RecInfo(val) => {
-      collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
+      annotated |=
+        collect_expr_references(&val.cnst.typ, &mut visited, &mut acc);
       for rule in &val.rules {
         acc.insert(rule.ctor.clone());
-        collect_expr_references(&rule.rhs, &mut visited, &mut acc);
+        annotated |= collect_expr_references(&rule.rhs, &mut visited, &mut acc);
       }
     },
   }
-  acc
+  (acc, annotated)
+}
+
+/// Match the reserved Lean metadata namespace by components, without allocating
+/// strings or relying on a hash match. This also catches malformed markers.
+fn is_source_contract_key(mut key: &Name) -> bool {
+  loop {
+    if let NameData::Str(source_parent, binder, _) = key.as_data()
+      && binder == "binder"
+      && let NameData::Str(ix_parent, source, _) = source_parent.as_data()
+      && source == "source"
+      && let NameData::Str(root, ix, _) = ix_parent.as_data()
+      && ix == "ix"
+      && matches!(root.as_data(), NameData::Anonymous(_))
+    {
+      return true;
+    }
+    match key.as_data() {
+      NameData::Str(parent, ..) | NameData::Num(parent, ..) => key = parent,
+      NameData::Anonymous(_) => return false,
+    }
+  }
 }
 
 /// Iterative DAG walk pushing every `Const`/`Proj` head into one shared
@@ -246,7 +290,8 @@ fn collect_expr_references<'a>(
   expr: &'a Expr,
   visited: &mut FxHashSet<&'a Expr>,
   acc: &mut NameSet,
-) {
+) -> bool {
+  let mut annotated = false;
   let mut stack: Vec<&'a Expr> = vec![expr];
   while let Some(e) = stack.pop() {
     if !visited.insert(e) {
@@ -269,7 +314,10 @@ fn collect_expr_references<'a>(
         stack.push(value);
         stack.push(body);
       },
-      ExprData::Mdata(_, inner, _) => stack.push(inner),
+      ExprData::Mdata(data, inner, _) => {
+        annotated |= data.iter().any(|(key, _)| is_source_contract_key(key));
+        stack.push(inner);
+      },
       ExprData::Proj(type_name, _, inner, _) => {
         acc.insert(type_name.clone());
         stack.push(inner);
@@ -277,6 +325,7 @@ fn collect_expr_references<'a>(
       _ => {},
     }
   }
+  annotated
 }
 
 #[cfg(test)]
@@ -297,6 +346,119 @@ mod tests {
     ConstantVal { name: n(name), level_params: vec![], typ: sort0() }
   }
 
+  fn source_key() -> Name {
+    ["ix", "source", "binder"]
+      .into_iter()
+      .fold(Name::anon(), |parent, part| Name::str(parent, part.to_owned()))
+  }
+
+  #[test]
+  fn source_contract_namespace_is_structural() {
+    let key = source_key();
+    assert!(is_source_contract_key(&key));
+    assert!(is_source_contract_key(&Name::str(key.clone(), "owned".into())));
+    assert!(is_source_contract_key(&Name::num(key, Nat::from(1u64))));
+    assert!(!is_source_contract_key(&n("ix.source.binder")));
+    assert!(!is_source_contract_key(&n("borrowed")));
+    assert!(!is_source_contract_key(&Name::str(
+      Name::str(n("ix"), "source".into()),
+      "binders".into()
+    )));
+  }
+
+  #[test]
+  fn source_contract_environment_rejects_before_emission() {
+    use crate::compile::{CompileOptions, compile_env_with_options};
+    use std::sync::Arc;
+
+    let mut env = Env::default();
+    for name in ["ZAnnotated", "AAnnotated"] {
+      env.insert(
+        n(name),
+        ConstantInfo::AxiomInfo(AxiomVal {
+          cnst: ConstantVal {
+            name: n(name),
+            level_params: vec![],
+            // Even malformed markers must not be discarded as presentation data.
+            typ: Expr::mdata(
+              vec![(source_key(), DataValue::OfBool(true))],
+              sort0(),
+            ),
+          },
+          is_unsafe: false,
+        }),
+      );
+    }
+    let env = Arc::new(env);
+    for workers in [1, 4] {
+      let pool =
+        rayon::ThreadPoolBuilder::new().num_threads(workers).build().unwrap();
+      let result = pool
+        .install(|| compile_env_with_options(&env, CompileOptions::default()));
+      assert!(
+        matches!(result, Err(ixon::CompileError::UnsupportedExpr { desc })
+        if desc == "unresolved source binder contracts: AAnnotated")
+      );
+    }
+  }
+
+  #[test]
+  fn source_contract_scan_covers_declaration_bodies() {
+    let mut env = Env::default();
+    let name = n("BodyMarker");
+    env.insert(
+      name.clone(),
+      ConstantInfo::DefnInfo(DefinitionVal {
+        cnst: ConstantVal {
+          name: name.clone(),
+          level_params: vec![],
+          typ: Expr::sort(Level::succ(Level::zero())),
+        },
+        value: Expr::mdata(
+          vec![(source_key(), DataValue::OfBool(true))],
+          sort0(),
+        ),
+        hints: ReducibilityHints::Abbrev,
+        safety: DefinitionSafety::Safe,
+        all: vec![name.clone()],
+      }),
+    );
+    assert_eq!(setup_scan(&env).source_contracts, vec![name]);
+  }
+
+  #[test]
+  fn source_contract_guard_preserves_native_borrow_metadata() {
+    use crate::compile::{CompileOptions, compile_env_with_options};
+    use std::sync::Arc;
+
+    let name = n("Ordinary");
+    let compile = |borrowed: bool| {
+      let mut env = Env::default();
+      let domain = if borrowed {
+        Expr::mdata(vec![(n("borrowed"), DataValue::OfBool(true))], sort0())
+      } else {
+        sort0()
+      };
+      env.insert(
+        name.clone(),
+        ConstantInfo::AxiomInfo(AxiomVal {
+          cnst: ConstantVal {
+            name: name.clone(),
+            level_params: vec![],
+            typ: Expr::all(n("x"), domain, sort0(), BinderInfo::Default),
+          },
+          is_unsafe: false,
+        }),
+      );
+      assert!(setup_scan(&env).source_contracts.is_empty());
+      let result =
+        compile_env_with_options(&Arc::new(env), CompileOptions::default())
+          .unwrap();
+      result.name_to_addr.get(&name).unwrap().value().clone()
+    };
+    assert_eq!(compile(false), compile(true));
+  }
+
   /// Frozen per-constant map/reduce implementation for differential tests
   /// and the opt-in performance comparison below.
   fn setup_scan_reference(env: &Env) -> SetupScan {
@@ -304,6 +466,7 @@ mod tests {
       graph: RefGraph::default(),
       immediate_ungrounded: FxHashMap::default(),
       ind_groups: FxHashMap::default(),
+      source_contracts: Vec::new(),
     };
     let names: Vec<_> = env.keys().collect();
     names
@@ -350,6 +513,7 @@ mod tests {
     assert_eq!(actual.graph.out_refs, expected.graph.out_refs);
     assert_eq!(actual.graph.in_refs, expected.graph.in_refs);
     assert_eq!(actual.ind_groups, expected.ind_groups);
+    assert_eq!(actual.source_contracts, expected.source_contracts);
     assert_eq!(
       actual.immediate_ungrounded.len(),
       expected.immediate_ungrounded.len()
@@ -515,10 +679,10 @@ mod tests {
       assert!(compiled.ungrounded.is_empty());
       let mut bytes = Vec::new();
       compiled.env.put(&mut bytes).unwrap();
-      // Captured from the per-constant scanner before the fold change.
+      // Migrated to Ixon v3; both worker counts must preserve these bytes.
       assert_eq!(
         blake3::hash(&bytes).to_hex().as_str(),
-        "d0a1c1490fad7e9e9236792c62ac3697dc7d3b541e3b3db12e00b9dd29ba36ed"
+        "34fe80b5eae41a9d430a4e2a61d499e9db25ea587af289f0b4fc63b7770924f5"
       );
     }
   }
diff --git a/crates/compile/src/lib.rs b/crates/compile/src/lib.rs
index 00cdee18b..c2ae119a0 100644
--- a/crates/compile/src/lib.rs
+++ b/crates/compile/src/lib.rs
@@ -9,4 +9,5 @@ pub mod graph;
 pub mod ground;
 pub mod kernel_egress;
 pub mod mutual;
+pub mod semantic_contract;
 pub mod store;
diff --git a/crates/compile/src/semantic_contract.rs b/crates/compile/src/semantic_contract.rs
new file mode 100644
index 000000000..68c59480e
--- /dev/null
+++ b/crates/compile/src/semantic_contract.rs
@@ -0,0 +1,577 @@
+//! Semantic contract nodes carried through the source compiler.
+//! Mirrors `Ix/SemanticContract.lean`; these frames are consumed into Ixon
+//! binders and never serve as a resource-validity certificate.
+
+use bignat::Nat;
+use ix_common::env::{DataValue, Expr as Source, ExprData, Name, NameData};
+use ixon::CompileError;
+use ixon::contract::{BinderContract, LetKind, ValueContract};
+use ixon::expr::Expr;
+use std::sync::Arc;
+
+fn error(desc: &str) -> CompileError {
+  CompileError::UnsupportedExpr { desc: desc.into() }
+}
+
+fn root(name: &Name) -> bool {
+  matches!(name.as_data(), NameData::Str(parent, text, _) if text == "contract" &&
+    matches!(parent.as_data(), NameData::Str(parent, text, _) if text == "ix" &&
+      matches!(parent.as_data(), NameData::Anonymous(_))))
+}
+
+pub fn reserved(mut name: &Name) -> bool {
+  loop {
+    if root(name) {
+      return true;
+    }
+    match name.as_data() {
+      NameData::Str(parent, ..) | NameData::Num(parent, ..) => name = parent,
+      NameData::Anonymous(_) => return false,
+    }
+  }
+}
+
+pub fn has_metadata(data: &[(Name, DataValue)]) -> bool {
+  data.iter().any(|(name, _)| reserved(name))
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Kind {
+  Lam,
+  All,
+  Let,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Contract {
+  pub kind: Kind,
+  pub binder: BinderContract,
+  pub result: ValueContract,
+  pub let_kind: LetKind,
+}
+
+impl Contract {
+  pub fn kind_code(self) -> u64 {
+    match self.kind {
+      Kind::Lam => 0,
+      Kind::All => 1,
+      Kind::Let => 2,
+    }
+  }
+  pub fn code(self) -> u8 {
+    let low = self.binder.to_bits();
+    match self.kind {
+      Kind::Lam => low,
+      Kind::All => low | (self.result.to_bits() << 4),
+      Kind::Let => {
+        low | if self.let_kind == LetKind::BorrowShared { 16 } else { 0 }
+      },
+    }
+  }
+  pub fn order_key(self) -> u64 {
+    self.kind_code() * 64 + u64::from(self.code())
+  }
+  pub fn metadata(self) -> Vec<(Name, DataValue)> {
+    let key =
+      Name::str(Name::str(Name::anon(), "ix".into()), "contract".into());
+    // Lean's KVMap.set appends a new field.
+    vec![
+      (key.clone(), DataValue::OfNat(Nat::from(3u64))),
+      (
+        Name::str(key.clone(), "kind".into()),
+        DataValue::OfNat(Nat::from(self.kind_code())),
+      ),
+      (
+        Name::str(key, "code".into()),
+        DataValue::OfNat(Nat::from(u64::from(self.code()))),
+      ),
+    ]
+  }
+  pub fn attach(self, source: Source) -> Source {
+    Source::mdata(self.metadata(), source)
+  }
+  pub fn lower(
+    self,
+    source: &Source,
+    compiled: &Arc<Expr>,
+  ) -> Result<Arc<Expr>, CompileError> {
+    Ok(Arc::new(match (self.kind, source.as_data(), compiled.as_ref()) {
+      (Kind::Lam, ExprData::Lam(..), Expr::Lam(_, typ, body)) => {
+        Expr::Lam(self.binder, typ.clone(), body.clone())
+      },
+      (Kind::All, ExprData::ForallE(..), Expr::All(_, _, typ, body)) => {
+        Expr::All(self.binder, self.result, typ.clone(), body.clone())
+      },
+      (Kind::Let, ExprData::LetE(..), Expr::Let(c, typ, value, body)) => {
+        Expr::Let(
+          ixon::contract::LetContract {
+            binder: self.binder,
+            kind: self.let_kind,
+            ..*c
+          },
+          typ.clone(),
+          value.clone(),
+          body.clone(),
+        )
+      },
+      _ => {
+        return Err(error(
+          "semantic contract is not attached to its original binder",
+        ));
+      },
+    }))
+  }
+}
+
+pub fn decode(kind: u64, code: u64) -> Result<Contract, CompileError> {
+  let kind = match kind {
+    0 => Kind::Lam,
+    1 => Kind::All,
+    2 => Kind::Let,
+    _ => return Err(error("invalid semantic contract kind")),
+  };
+  let limit = match kind {
+    Kind::Lam => 16,
+    Kind::All => 64,
+    Kind::Let => 32,
+  };
+  if code >= limit {
+    return Err(error("reserved semantic contract bits"));
+  }
+  let code = u8::try_from(code)
+    .map_err(|_error| error("semantic contract code overflow"))?;
+  let binder = BinderContract::from_bits(code % 16)
+    .ok_or_else(|| error("invalid semantic binder contract"))?;
+  let result = if kind == Kind::All {
+    ValueContract::from_bits(code / 16)
+      .ok_or_else(|| error("invalid semantic result contract"))?
+  } else {
+    ValueContract::shared()
+  };
+  let let_kind = if kind == Kind::Let && code >= 16 {
+    LetKind::BorrowShared
+  } else {
+    LetKind::Value
+  };
+  if let_kind == LetKind::BorrowShared
+    && binder.value != ValueContract::local_shared()
+  {
+    return Err(error("shared borrow requires a shared local view"));
+  }
+  Ok(Contract { kind, binder, result, let_kind })
+}
+
+pub fn read(data: &[(Name, DataValue)]) -> Result<Contract, CompileError> {
+  if data.len() != 3 {
+    return Err(error("malformed semantic contract frame"));
+  }
+  let (mut version, mut kind, mut code) = (None, None, None);
+  for (name, value) in data {
+    let DataValue::OfNat(value) = value else {
+      return Err(error("semantic contract fields must be natural numbers"));
+    };
+    let value = value
+      .to_u64()
+      .ok_or_else(|| error("semantic contract field is too large"))?;
+    let slot = if root(name) {
+      &mut version
+    } else {
+      match name.as_data() {
+        NameData::Str(parent, text, _) if root(parent) && text == "kind" => {
+          &mut kind
+        },
+        NameData::Str(parent, text, _) if root(parent) && text == "code" => {
+          &mut code
+        },
+        _ => return Err(error("unknown or duplicate semantic contract field")),
+      }
+    };
+    if slot.replace(value).is_some() {
+      return Err(error("unknown or duplicate semantic contract field"));
+    }
+  }
+  if version != Some(3) {
+    return Err(error("unsupported semantic contract version"));
+  }
+  decode(
+    kind.ok_or_else(|| error("missing semantic contract kind"))?,
+    code.ok_or_else(|| error("missing semantic contract code"))?,
+  )
+}
+
+pub fn inspect(top: &Source) -> Result<bool, CompileError> {
+  let mut seen = rustc_hash::FxHashSet::default();
+  let mut stack = vec![top];
+  let mut annotated = false;
+  while let Some(expr) = stack.pop() {
+    if !seen.insert(expr) {
+      continue;
+    }
+    match expr.as_data() {
+      ExprData::App(f, a, _) => {
+        stack.push(f);
+        stack.push(a);
+      },
+      ExprData::Lam(_, t, b, ..) | ExprData::ForallE(_, t, b, ..) => {
+        stack.push(t);
+        stack.push(b);
+      },
+      ExprData::LetE(_, t, v, b, ..) => {
+        stack.push(t);
+        stack.push(v);
+        stack.push(b);
+      },
+      ExprData::Proj(_, _, v, _) => stack.push(v),
+      ExprData::Mdata(data, inner, _) => {
+        if has_metadata(data) {
+          let c = read(data)?;
+          if !matches!(
+            (c.kind, inner.as_data()),
+            (Kind::Lam, ExprData::Lam(..))
+              | (Kind::All, ExprData::ForallE(..))
+              | (Kind::Let, ExprData::LetE(..))
+          ) {
+            return Err(error(
+              "semantic contract is not attached to its original binder",
+            ));
+          }
+          annotated = true;
+        }
+        stack.push(inner);
+      },
+      _ => {},
+    }
+  }
+  Ok(annotated)
+}
+
+pub fn inspect_constant(
+  c: &ix_common::env::ConstantInfo,
+) -> Result<bool, CompileError> {
+  let mut annotated = inspect(c.get_type())?;
+  if let Some(body) = c.get_value() {
+    annotated |= inspect(body)?;
+  }
+  if let ix_common::env::ConstantInfo::RecInfo(r) = c {
+    for rule in &r.rules {
+      annotated |= inspect(&rule.rhs)?;
+    }
+  }
+  if annotated
+    && !matches!(
+      c,
+      ix_common::env::ConstantInfo::DefnInfo(_)
+        | ix_common::env::ConstantInfo::ThmInfo(_)
+        | ix_common::env::ConstantInfo::OpaqueInfo(_)
+        | ix_common::env::ConstantInfo::AxiomInfo(_)
+    )
+  {
+    return Err(error(
+      "annotated inductive/constructor/recursor transformations are unsupported",
+    ));
+  }
+  Ok(annotated)
+}
+
+pub fn of_ixon(expr: &Expr) -> Option<Contract> {
+  let c = match expr {
+    Expr::Lam(binder, ..) => Contract {
+      kind: Kind::Lam,
+      binder: *binder,
+      result: ValueContract::shared(),
+      let_kind: LetKind::Value,
+    },
+    Expr::All(binder, result, ..) => Contract {
+      kind: Kind::All,
+      binder: *binder,
+      result: *result,
+      let_kind: LetKind::Value,
+    },
+    Expr::Let(c, ..) => Contract {
+      kind: Kind::Let,
+      binder: c.binder,
+      result: ValueContract::shared(),
+      let_kind: c.kind,
+    },
+    _ => return None,
+  };
+  (c.binder != BinderContract::default()
+    || c.result != ValueContract::shared()
+    || c.let_kind != LetKind::Value)
+    .then_some(c)
+}
+
+/// Context-free presence scan only; never used as resource-validity evidence.
+pub fn contains_ixon(
+  expr: &Arc<Expr>,
+  sharing: &[Arc<Expr>],
+) -> Result<bool, String> {
+  let mut seen = rustc_hash::FxHashSet::default();
+  let mut stack = vec![expr];
+  while let Some(e) = stack.pop() {
+    if !seen.insert(Arc::as_ptr(e)) {
+      continue;
+    }
+    if of_ixon(e).is_some() {
+      return Ok(true);
+    }
+    if let Expr::Share(index) = e.as_ref() {
+      stack.push(
+        sharing
+          .get(
+            usize::try_from(*index)
+              .map_err(|_error| "semantic scan: sharing index overflow")?,
+          )
+          .ok_or("semantic scan: invalid sharing index")?,
+      );
+    } else {
+      stack.extend(e.children());
+    }
+  }
+  Ok(false)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::compile::{BlockCache, CompileState, compare_expr, compile_expr};
+  use crate::mutual::MutCtx;
+  use ix_common::env::{BinderInfo, Level};
+  #[test]
+  fn strict_metadata_and_all_contract_codes() {
+    for (kind, count) in [(0, 16), (1, 64), (2, 32)] {
+      for code in 0..count {
+        match decode(kind, code) {
+          Ok(contract) => {
+            assert_eq!(read(&contract.metadata()).unwrap(), contract);
+            assert_eq!(u64::from(contract.code()), code);
+          },
+          Err(_) => assert!(kind == 2 && code >= 16 && (code % 16) / 4 != 3),
+        }
+      }
+      assert!(decode(kind, count).is_err());
+    }
+    let data = decode(0, 1).unwrap().metadata();
+    assert!(has_metadata(&data));
+    assert!(read(&data[..2]).is_err());
+    let mut duplicate = data.clone();
+    duplicate[0] = duplicate[1].clone();
+    assert!(read(&duplicate).is_err());
+    let mut wrong = data;
+    wrong[0].1 = DataValue::OfNat(Nat::from(2u64));
+    assert!(read(&wrong).is_err());
+  }
+
+  #[test]
+  fn lowering_cache_ordering_and_borrow_contracts() {
+    let stt = CompileState::default();
+    let mut cache = BlockCache::default();
+    let domain = Source::sort(Level::zero());
+    let body = Source::bvar(Nat::from(0u64));
+    let lambda = Source::lam(
+      Name::anon(),
+      domain.clone(),
+      body.clone(),
+      BinderInfo::Default,
+    );
+    let arrow = Source::all(
+      Name::anon(),
+      domain.clone(),
+      domain.clone(),
+      BinderInfo::Default,
+    );
+    let mut lambdas = vec![];
+    for code in 0..16 {
+      let contract = decode(0, code).unwrap();
+      let source = contract.attach(lambda.clone());
+      let output =
+        compile_expr(&source, &[], &MutCtx::default(), &mut cache, &stt)
+          .unwrap();
+      assert_eq!(
+        output,
+        Expr::lam_contract(contract.binder, Expr::sort(0), Expr::var(0))
+      );
+      lambdas.push(source);
+    }
+    for code in 0..64 {
+      let contract = decode(1, code).unwrap();
+      let source = contract.attach(arrow.clone());
+      let output =
+        compile_expr(&source, &[], &MutCtx::default(), &mut cache, &stt)
+          .unwrap();
+      assert_eq!(
+        output,
+        Expr::all_contract(
+          contract.binder,
+          contract.result,
+          Expr::sort(0),
+          Expr::sort(0)
+        )
+      );
+    }
+    for (i, a) in lambdas.iter().enumerate() {
+      for (j, b) in lambdas.iter().enumerate() {
+        let order =
+          compare_expr(a, b, &MutCtx::default(), &[], &[], &stt).unwrap();
+        assert_eq!(order.ordering == std::cmp::Ordering::Equal, i == j);
+      }
+    }
+    let plain = Source::letE(
+      Name::anon(),
+      domain.clone(),
+      body.clone(),
+      body.clone(),
+      false,
+    );
+    let contract = decode(2, 30).unwrap();
+    let borrowed = contract.attach(plain.clone());
+    let expected = Expr::let_contract(
+      ixon::contract::LetContract {
+        non_dep: false,
+        kind: LetKind::BorrowShared,
+        binder: contract.binder,
+      },
+      Expr::sort(0),
+      Expr::var(0),
+      Expr::var(0),
+    );
+    for (source, expected) in [
+      (&plain, Expr::let_(false, Expr::sort(0), Expr::var(0), Expr::var(0))),
+      (&borrowed, expected),
+      (&plain, Expr::let_(false, Expr::sort(0), Expr::var(0), Expr::var(0))),
+    ] {
+      assert_eq!(
+        compile_expr(source, &[], &MutCtx::default(), &mut cache, &stt)
+          .unwrap(),
+        expected
+      );
+    }
+    assert!(
+      compile_expr(
+        &contract.attach(domain.clone()),
+        &[],
+        &MutCtx::default(),
+        &mut cache,
+        &stt
+      )
+      .is_err()
+    );
+    let bad =
+      Source::mdata(decode(0, 1).unwrap().metadata()[..1].to_vec(), domain);
+    assert!(
+      compile_expr(&bad, &[], &MutCtx::default(), &mut cache, &stt).is_err()
+    );
+  }
+  #[test]
+  fn committed_contracts_roundtrip_without_optional_metadata() {
+    use crate::decompile::{
+      BlockCache as DecompileCache, DecompileState, decompile_expr,
+    };
+    use ixon::metadata::{DataValue, ExprMeta, ExprMetaData};
+    let stt = CompileState::new_empty();
+    let mut terms = vec![];
+    for bits in 0..16 {
+      let c = BinderContract::from_bits(bits).unwrap();
+      terms.push(Expr::lam_contract(c, Expr::sort(0), Expr::var(0)));
+      for result in 0..4 {
+        terms.push(Expr::all_contract(
+          c,
+          ValueContract::from_bits(result).unwrap(),
+          Expr::sort(0),
+          Expr::sort(0),
+        ));
+      }
+      for non_dep in [false, true] {
+        for kind in [LetKind::Value, LetKind::BorrowShared] {
+          if kind == LetKind::BorrowShared
+            && c.value != ValueContract::local_shared()
+          {
+            continue;
+          }
+          terms.push(Expr::let_contract(
+            ixon::contract::LetContract { non_dep, kind, binder: c },
+            Expr::sort(0),
+            Expr::var(0),
+            Expr::var(0),
+          ));
+        }
+      }
+    }
+    for term in terms {
+      let mut cache = DecompileCache {
+        univ_table: vec![ixon::univ::Univ::zero()],
+        ..Default::default()
+      };
+      let source = decompile_expr(
+        &term,
+        &ExprMeta::default(),
+        u64::MAX,
+        &[],
+        &mut cache,
+        &stt,
+        &DecompileState::default(),
+      )
+      .unwrap();
+      let result = compile_expr(
+        &source,
+        &[],
+        &MutCtx::default(),
+        &mut BlockCache::default(),
+        &stt,
+      )
+      .unwrap();
+      assert_eq!(result, term);
+    }
+    let nested = Expr::lam_contract(
+      BinderContract {
+        uses: ixon::expr::Uses::Affine,
+        value: ValueContract::local_unique(),
+      },
+      Expr::sort(0),
+      Expr::var(0),
+    );
+    let mut cache =
+      DecompileCache { sharing: vec![nested], ..Default::default() };
+    let mut arena = ExprMeta::default();
+    let root = arena.alloc(ExprMetaData::CallSite {
+      name: ix_common::address::Address::hash(b"unused"),
+      entries: vec![],
+      canon_meta: vec![],
+      orig_head: None,
+    });
+    assert!(
+      decompile_expr(
+        &Expr::app(Expr::var(0), Expr::share(0)),
+        &arena,
+        root,
+        &[],
+        &mut cache,
+        &stt,
+        &DecompileState::default()
+      )
+      .is_err()
+    );
+
+    let key =
+      Name::str(Name::str(Name::anon(), "ix".into()), "contract".into());
+    let addr = ix_common::address::Address::from_blake3_hash(*key.get_hash());
+    stt.env.store_name(addr.clone(), key);
+    let leaf = arena.alloc(ExprMetaData::Leaf);
+    let root = arena.alloc(ExprMetaData::Mdata {
+      mdata: vec![vec![(addr, DataValue::OfBool(true))]],
+      child: leaf,
+    });
+    assert!(
+      decompile_expr(
+        &Expr::var(0),
+        &arena,
+        root,
+        &[],
+        &mut DecompileCache::default(),
+        &stt,
+        &DecompileState::default()
+      )
+      .is_err()
+    );
+  }
+}
diff --git a/crates/ffi/src/compile.rs b/crates/ffi/src/compile.rs
index 3b4021a39..e8d111db3 100644
--- a/crates/ffi/src/compile.rs
+++ b/crates/ffi/src/compile.rs
@@ -27,7 +27,7 @@ use ixon::constant::Constant as IxonConstant;
 #[cfg(feature = "test-ffi")]
 use ixon::constant::ConstantInfo;
 #[cfg(feature = "test-ffi")]
-use ixon::expr::{Expr as IxonExpr, Owned as IxonOwned, Uses as IxonUses};
+use ixon::expr::Expr as IxonExpr;
 use ixon::{Comm, ConstantMeta};
 use lean_ffi::object::LeanIOResult;
 use lean_ffi::object::LeanNat;
@@ -573,20 +573,44 @@ pub extern "C" fn rs_compile_phases(
 #[unsafe(no_mangle)]
 pub extern "C" fn rs_compile_env_to_ixon(
   env_consts_ptr: LeanList<LeanBorrowed<'_>>,
+) -> LeanIOResult<LeanOwned> {
+  compile_env_to_ixon_profile(env_consts_ptr, None)
+}
+
+/// Explicit canonical policy; the native compiler validates it before emission.
+#[unsafe(no_mangle)]
+pub extern "C" fn rs_compile_env_to_ixon_profile(
+  env_consts_ptr: LeanList<LeanBorrowed<'_>>,
+  bytes: LeanByteArray<LeanBorrowed<'_>>,
+) -> LeanIOResult<LeanOwned> {
+  let profile =
+    match ixon::resource::addressed::Profile::from_bytes(bytes.as_bytes()) {
+      Ok(profile) => profile,
+      Err(error) => return LeanIOResult::error_string(&error),
+    };
+  compile_env_to_ixon_profile(env_consts_ptr, Some(&profile))
+}
+
+fn compile_env_to_ixon_profile(
+  env_consts_ptr: LeanList<LeanBorrowed<'_>>,
+  profile: Option<&ixon::resource::addressed::Profile>,
 ) -> LeanIOResult<LeanOwned> {
   {
     let rust_env = crate::lean_env::decode_env(env_consts_ptr);
     let rust_env = Arc::new(rust_env);
 
-    let compile_stt =
-      match compile_env_with_options(&rust_env, CompileOptions::default()) {
-        Ok(stt) => stt,
-        Err(e) => {
-          let msg =
-            format!("rs_compile_env_to_ixon: compilation failed: {:?}", e);
-          return LeanIOResult::error_string(&msg);
-        },
-      };
+    let compile_stt = match ix_compile::compile::compile_env_with_profile(
+      &rust_env,
+      CompileOptions::default(),
+      profile,
+    ) {
+      Ok(stt) => stt,
+      Err(e) => {
+        let msg =
+          format!("rs_compile_env_to_ixon: compilation failed: {:?}", e);
+        return LeanIOResult::error_string(&msg);
+      },
+    };
 
     let mut cache = LeanBuildCache::with_capacity(rust_env.len());
 
@@ -936,96 +960,44 @@ extern "C" fn rs_get_block_sharing_len(
 // =============================================================================
 
 #[cfg(feature = "test-ffi")]
-/// Frame for iterative unshare traversal.
-enum UnshareFrame<'a> {
-  Visit(&'a Arc<IxonExpr>),
-  BuildApp,
-  BuildLam(IxonUses),
-  BuildAll(IxonUses, IxonOwned),
-  BuildLet(bool),
-  BuildPrj(u64, u64),
-}
-
-#[cfg(feature = "test-ffi")]
-/// Expand Share(idx) references in an expression using the sharing vector.
-/// This reconstructs the "pre-sharing" expression from the post-sharing
-/// representation. Uses iterative traversal to avoid stack overflow on deep
-/// expressions.
-#[allow(clippy::cast_possible_truncation)]
+/// Expand shares while preserving all v3 contracts and static groups.
 fn unshare_expr(
   expr: &Arc<IxonExpr>,
   sharing: &[Arc<IxonExpr>],
 ) -> Arc<IxonExpr> {
-  let mut stack: Vec<UnshareFrame<'_>> = vec![UnshareFrame::Visit(expr)];
-  let mut results: Vec<Arc<IxonExpr>> = Vec::new();
-
+  enum Frame<'a> {
+    Visit(&'a Arc<IxonExpr>),
+    Build(&'a IxonExpr),
+  }
+  let mut stack = vec![Frame::Visit(expr)];
+  let mut results: Vec<Arc<IxonExpr>> = vec![];
   while let Some(frame) = stack.pop() {
     match frame {
-      UnshareFrame::Visit(e) => match e.as_ref() {
-        IxonExpr::Share(idx) => {
-          if (*idx as usize) < sharing.len() {
-            stack.push(UnshareFrame::Visit(&sharing[*idx as usize]));
-          } else {
-            results.push(e.clone());
-          }
-        },
-        IxonExpr::App(f, a) => {
-          stack.push(UnshareFrame::BuildApp);
-          stack.push(UnshareFrame::Visit(a));
-          stack.push(UnshareFrame::Visit(f));
-        },
-        IxonExpr::Lam(uses, t, b) => {
-          stack.push(UnshareFrame::BuildLam(*uses));
-          stack.push(UnshareFrame::Visit(b));
-          stack.push(UnshareFrame::Visit(t));
-        },
-        IxonExpr::All(uses, owned, t, b) => {
-          stack.push(UnshareFrame::BuildAll(*uses, *owned));
-          stack.push(UnshareFrame::Visit(b));
-          stack.push(UnshareFrame::Visit(t));
-        },
-        IxonExpr::Let(nd, t, v, b) => {
-          stack.push(UnshareFrame::BuildLet(*nd));
-          stack.push(UnshareFrame::Visit(b));
-          stack.push(UnshareFrame::Visit(v));
-          stack.push(UnshareFrame::Visit(t));
-        },
-        IxonExpr::Prj(ti, fi, v) => {
-          stack.push(UnshareFrame::BuildPrj(*ti, *fi));
-          stack.push(UnshareFrame::Visit(v));
-        },
-        // Leaf nodes - no children to unshare
-        _ => results.push(e.clone()),
-      },
-      UnshareFrame::BuildApp => {
-        let a = results.pop().unwrap();
-        let f = results.pop().unwrap();
-        results.push(Arc::new(IxonExpr::App(f, a)));
-      },
-      UnshareFrame::BuildLam(uses) => {
-        let b = results.pop().unwrap();
-        let t = results.pop().unwrap();
-        results.push(Arc::new(IxonExpr::Lam(uses, t, b)));
-      },
-      UnshareFrame::BuildAll(uses, owned) => {
-        let b = results.pop().unwrap();
-        let t = results.pop().unwrap();
-        results.push(Arc::new(IxonExpr::All(uses, owned, t, b)));
-      },
-      UnshareFrame::BuildLet(nd) => {
-        let b = results.pop().unwrap();
-        let v = results.pop().unwrap();
-        let t = results.pop().unwrap();
-        results.push(Arc::new(IxonExpr::Let(nd, t, v, b)));
+      Frame::Visit(e) => {
+        if let IxonExpr::Share(idx) = e.as_ref()
+          && let Ok(idx) = usize::try_from(*idx)
+          && let Some(shared) = sharing.get(idx)
+        {
+          stack.push(Frame::Visit(shared));
+          continue;
+        }
+        let children = e.children();
+        if children.is_empty() {
+          results.push(e.clone());
+        } else {
+          stack.push(Frame::Build(e));
+          stack.extend(children.into_iter().rev().map(Frame::Visit));
+        }
       },
-      UnshareFrame::BuildPrj(ti, fi) => {
-        let v = results.pop().unwrap();
-        results.push(Arc::new(IxonExpr::Prj(ti, fi, v)));
+      Frame::Build(e) => {
+        let children = results.split_off(results.len() - e.children().len());
+        results.push(Arc::new(
+          e.with_children(&children).expect("unshare child count"),
+        ));
       },
     }
   }
-
-  results.pop().unwrap()
+  results.pop().expect("unshare result")
 }
 
 /// FFI: Get the pre-sharing root expressions for a constant.
diff --git a/crates/ffi/src/ix/data.rs b/crates/ffi/src/ix/data.rs
index 355be8bbb..98f99cba4 100644
--- a/crates/ffi/src/ix/data.rs
+++ b/crates/ffi/src/ix/data.rs
@@ -50,7 +50,7 @@ impl LeanIxSubstring<LeanOwned> {
   /// Build a Ix.Substring.
   pub fn build(ss: &Substring) -> Self {
     let ctor = LeanIxSubstring::alloc(0);
-    ctor.set_obj(0, LeanString::new(ss.str.as_str()));
+    ctor.set_obj(0, LeanString::from_bytes(ss.str.as_bytes()));
     ctor.set_obj(1, LeanNat::from_nat(&ss.start_pos));
     ctor.set_obj(2, LeanNat::from_nat(&ss.stop_pos));
     ctor
@@ -176,7 +176,7 @@ impl<R: LeanRef> LeanIxSyntaxPreresolved<R> {
 pub fn build_string_array(strings: &[String]) -> LeanArray<LeanOwned> {
   let arr = LeanArray::alloc(strings.len());
   for (i, s) in strings.iter().enumerate() {
-    arr.set(i, LeanString::new(s.as_str()));
+    arr.set(i, LeanString::from_bytes(s.as_bytes()));
   }
   arr
 }
@@ -199,7 +199,7 @@ impl LeanIxSyntax<LeanOwned> {
       Syntax::Atom(info, val) => {
         let ctor = LeanIxSyntax::alloc(2);
         ctor.set_obj(0, LeanIxSourceInfo::build(info));
-        ctor.set_obj(1, LeanString::new(val.as_str()));
+        ctor.set_obj(1, LeanString::from_bytes(val.as_bytes()));
         ctor
       },
       // | ident (info : SourceInfo) (rawVal : Substring) (val : Name) (preresolved : Array SyntaxPreresolved) -- tag 3
@@ -283,7 +283,7 @@ impl LeanIxDataValue<LeanOwned> {
     match dv {
       DataValue::OfString(s) => {
         let ctor = LeanIxDataValue::alloc(0);
-        ctor.set_obj(0, LeanString::new(s.as_str()));
+        ctor.set_obj(0, LeanString::from_bytes(s.as_bytes()));
         ctor
       },
       DataValue::OfBool(b) => {
diff --git a/crates/ffi/src/ix/expr.rs b/crates/ffi/src/ix/expr.rs
index 4b5e4bfc1..1d80f65a5 100644
--- a/crates/ffi/src/ix/expr.rs
+++ b/crates/ffi/src/ix/expr.rs
@@ -267,8 +267,9 @@ impl LeanIxLiteral<LeanOwned> {
         ctor
       },
       Literal::StrVal(s) => {
+        // Preserve NUL bytes instead of filtering them through a C string.
         let ctor = LeanIxLiteral::alloc(1);
-        ctor.set_obj(0, LeanString::new(s.as_str()));
+        ctor.set_obj(0, LeanString::from_bytes(s.as_bytes()));
         ctor
       },
     }
diff --git a/crates/ffi/src/ix/name.rs b/crates/ffi/src/ix/name.rs
index be3597239..346698a2c 100644
--- a/crates/ffi/src/ix/name.rs
+++ b/crates/ffi/src/ix/name.rs
@@ -32,7 +32,7 @@ impl LeanIxName<LeanOwned> {
       },
       NameData::Str(parent, s, h) => {
         let parent_obj = Self::build(cache, parent);
-        let s_obj = LeanString::new(s.as_str());
+        let s_obj = LeanString::from_bytes(s.as_bytes());
         let ctor = LeanIxName::alloc(1);
         ctor.set_obj(0, parent_obj);
         ctor.set_obj(1, s_obj);
diff --git a/crates/ffi/src/kernel.rs b/crates/ffi/src/kernel.rs
index 02525767a..1f98b5581 100644
--- a/crates/ffi/src/kernel.rs
+++ b/crates/ffi/src/kernel.rs
@@ -552,16 +552,16 @@ fn wrong_successor_rule_returning_first_minor(
     IxonExpr::Lam(motive_uses, motive_ty, rest) => match rest.as_ref() {
       IxonExpr::Lam(h_zero_uses, h_zero_ty, rest) => match rest.as_ref() {
         IxonExpr::Lam(h_succ_uses, h_succ_ty, rest) => match rest.as_ref() {
-          IxonExpr::Lam(n_uses, n_ty, _) => Ok(IxonExpr::lam_mode(
+          IxonExpr::Lam(n_uses, n_ty, _) => Ok(IxonExpr::lam_contract(
             *motive_uses,
             motive_ty.clone(),
-            IxonExpr::lam_mode(
+            IxonExpr::lam_contract(
               *h_zero_uses,
               h_zero_ty.clone(),
-              IxonExpr::lam_mode(
+              IxonExpr::lam_contract(
                 *h_succ_uses,
                 h_succ_ty.clone(),
-                IxonExpr::lam_mode(*n_uses, n_ty.clone(), IxonExpr::var(2)),
+                IxonExpr::lam_contract(*n_uses, n_ty.clone(), IxonExpr::var(2)),
               ),
             ),
           )),
diff --git a/crates/ffi/src/lean.rs b/crates/ffi/src/lean.rs
index cf4ab2645..26271814c 100644
--- a/crates/ffi/src/lean.rs
+++ b/crates/ffi/src/lean.rs
@@ -33,6 +33,9 @@ lean_ffi::lean_domain_type! {
 lean_ffi::lean_inductive! {
   // --- Ixon structures (single-constructor) ---
 
+  LeanIxonValueContract  [ { num_8: 2 } ];
+  LeanIxonBinderContract [ { num_obj: 1, num_8: 1 } ];
+  LeanIxonLetContract    [ { num_obj: 1, num_8: 2 } ];
   LeanIxonDefinition      [ { num_obj: 2, num_64: 1, num_8: 2 } ];
   LeanIxonRecursorRule    [ { num_obj: 1, num_64: 1 } ];
   LeanIxonRecursor        [ { num_obj: 2, num_64: 5, num_8: 2 } ];
@@ -93,9 +96,9 @@ lean_ffi::lean_inductive! {
     { num_64: 1 },                            // tag 5: str
     { num_64: 1 },                            // tag 6: nat
     { num_obj: 2 },                           // tag 7: app
-    { num_obj: 2, num_8: 1 },                 // tag 8: lam (uses)
-    { num_obj: 2, num_8: 2 },                 // tag 9: all (uses, owned)
-    { num_obj: 3, num_8: 1 },                 // tag 10: let
+    { num_obj: 3 },                           // tag 8: lam
+    { num_obj: 4 },                           // tag 9: all
+    { num_obj: 4 },                           // tag 10: let
     { num_64: 1 },                            // tag 11: share
   ];
 
diff --git a/crates/ffi/src/lean_build.rs b/crates/ffi/src/lean_build.rs
index 94971078f..a76c4aa39 100644
--- a/crates/ffi/src/lean_build.rs
+++ b/crates/ffi/src/lean_build.rs
@@ -142,7 +142,7 @@ pub fn encode_name(cache: &mut LeanEncodeCache, name: &Name) -> LeanOwned {
     NameData::Anonymous(_) => unreachable!("handled above"),
     NameData::Str(parent, s, _) => {
       let parent = encode_name(cache, parent);
-      let part = LeanString::new(s);
+      let part = LeanString::from_bytes(s.as_bytes());
       unsafe {
         LeanOwned::from_raw(lean_name_mk_string(
           parent.into_raw(),
@@ -214,7 +214,7 @@ pub fn encode_level(cache: &mut LeanEncodeCache, level: &Level) -> LeanOwned {
 
 fn encode_substring(s: &Substring) -> LeanOwned {
   let obj = LeanIxSubstring::alloc(0);
-  obj.set_obj(0, LeanString::new(&s.str));
+  obj.set_obj(0, LeanString::from_bytes(s.str.as_bytes()));
   obj.set_obj(1, LeanNat::from_nat(&s.start_pos));
   obj.set_obj(2, LeanNat::from_nat(&s.stop_pos));
   obj.into()
@@ -256,7 +256,10 @@ fn encode_syntax_preresolved(
       obj.set_obj(0, encode_name(cache, name));
       obj.set_obj(
         1,
-        fields.iter().map(|f| LeanString::new(f)).collect::<LeanList<_>>(),
+        fields
+          .iter()
+          .map(|f| LeanString::from_bytes(f.as_bytes()))
+          .collect::<LeanList<_>>(),
       );
       obj.into()
     },
@@ -280,7 +283,7 @@ fn encode_syntax(cache: &mut LeanEncodeCache, syn: &Syntax) -> LeanOwned {
     Syntax::Atom(info, val) => {
       let obj = LeanIxSyntax::alloc(2);
       obj.set_obj(0, encode_source_info(info));
-      obj.set_obj(1, LeanString::new(val));
+      obj.set_obj(1, LeanString::from_bytes(val.as_bytes()));
       obj.into()
     },
     Syntax::Ident(info, raw_val, val, preresolved) => {
@@ -307,7 +310,7 @@ fn encode_data_value(
   Ok(match dv {
     DataValue::OfString(s) => {
       let obj = LeanIxDataValue::alloc(0);
-      obj.set_obj(0, LeanString::new(s));
+      obj.set_obj(0, LeanString::from_bytes(s.as_bytes()));
       obj.into()
     },
     DataValue::OfBool(b) => {
@@ -364,8 +367,9 @@ fn encode_literal(lit: &Literal) -> LeanOwned {
       obj.into()
     },
     Literal::StrVal(s) => {
+      // Source strings may contain NULs; the C-string constructor drops them.
       let obj = LeanIxLiteral::alloc(1);
-      obj.set_obj(0, LeanString::new(s));
+      obj.set_obj(0, LeanString::from_bytes(s.as_bytes()));
       obj.into()
     },
   }
diff --git a/crates/ffi/src/lean_env.rs b/crates/ffi/src/lean_env.rs
index 6c48ef5e6..6eae3edab 100644
--- a/crates/ffi/src/lean_env.rs
+++ b/crates/ffi/src/lean_env.rs
@@ -2766,33 +2766,16 @@ extern "C" fn rs_compile_validate_aux(
             || expr.clone(),
             |shared| expand_shares_expr(shared, sharing),
           ),
-          Expr::Prj(type_ref_idx, field_idx, val) => Expr::prj(
-            *type_ref_idx,
-            *field_idx,
-            expand_shares_expr(val, sharing),
-          ),
-          Expr::App(fun, arg) => Expr::app(
-            expand_shares_expr(fun, sharing),
-            expand_shares_expr(arg, sharing),
-          ),
-          Expr::Lam(uses, ty, body) => Expr::lam_mode(
-            *uses,
-            expand_shares_expr(ty, sharing),
-            expand_shares_expr(body, sharing),
-          ),
-          Expr::All(uses, owned, ty, body) => Expr::all_mode(
-            *uses,
-            *owned,
-            expand_shares_expr(ty, sharing),
-            expand_shares_expr(body, sharing),
-          ),
-          Expr::Let(non_dep, ty, val, body) => Expr::let_(
-            *non_dep,
-            expand_shares_expr(ty, sharing),
-            expand_shares_expr(val, sharing),
-            expand_shares_expr(body, sharing),
-          ),
-          _ => expr.clone(),
+          _ => {
+            let children: Vec<_> = expr
+              .children()
+              .into_iter()
+              .map(|child| expand_shares_expr(child, sharing))
+              .collect();
+            Arc::new(
+              expr.with_children(&children).expect("share reconstruction"),
+            )
+          },
         }
       }
 
diff --git a/crates/ffi/src/lean_ixon.rs b/crates/ffi/src/lean_ixon.rs
index 8cc7a26e6..b6c20da4f 100644
--- a/crates/ffi/src/lean_ixon.rs
+++ b/crates/ffi/src/lean_ixon.rs
@@ -6,6 +6,7 @@
 #[cfg(feature = "test-ffi")]
 pub mod compare;
 pub mod constant;
+pub mod contract;
 pub mod diff;
 pub mod enums;
 pub mod env;
diff --git a/crates/ffi/src/lean_ixon/contract.rs b/crates/ffi/src/lean_ixon/contract.rs
new file mode 100644
index 000000000..2808ed1ea
--- /dev/null
+++ b/crates/ffi/src/lean_ixon/contract.rs
@@ -0,0 +1,72 @@
+//! Semantic usage, ownership, locality, and let-kind contracts.
+
+use crate::lean::{
+  LeanIxonBinderContract, LeanIxonLetContract, LeanIxonValueContract,
+};
+use ixon::contract::{
+  BinderContract, LetContract, LetKind, Locality, ValueContract,
+};
+use ixon::expr::{Owned, Uses};
+use lean_ffi::object::{LeanOwned, LeanRef};
+
+impl LeanIxonValueContract<LeanOwned> {
+  pub fn build(v: &ValueContract) -> Self {
+    let ctor = Self::alloc(0);
+    ctor.set_num_8(0, v.owned.to_bits());
+    ctor.set_num_8(1, v.locality.to_bits());
+    ctor
+  }
+}
+
+impl<R: LeanRef> LeanIxonValueContract<R> {
+  pub fn decode(&self) -> ValueContract {
+    ValueContract {
+      owned: Owned::from_bits(self.get_num_8(0))
+        .expect("invalid Ixon.Owned tag"),
+      locality: Locality::from_bits(self.get_num_8(1))
+        .expect("invalid Ixon.Locality tag"),
+    }
+  }
+}
+
+impl LeanIxonBinderContract<LeanOwned> {
+  pub fn build(b: &BinderContract) -> Self {
+    let ctor = Self::alloc(0);
+    ctor.set_obj(0, LeanIxonValueContract::build(&b.value));
+    ctor.set_num_8(0, b.uses.to_bits());
+    ctor
+  }
+}
+
+impl<R: LeanRef> LeanIxonBinderContract<R> {
+  pub fn decode(&self) -> BinderContract {
+    BinderContract {
+      uses: Uses::from_bits(self.get_num_8(0)).expect("invalid Ixon.Uses tag"),
+      value: LeanIxonValueContract(self.get_obj(0)).decode(),
+    }
+  }
+}
+
+impl LeanIxonLetContract<LeanOwned> {
+  pub fn build(c: &LetContract) -> Self {
+    let ctor = Self::alloc(0);
+    ctor.set_obj(0, LeanIxonBinderContract::build(&c.binder));
+    ctor.set_num_8(0, u8::from(c.non_dep));
+    ctor.set_num_8(1, c.kind as u8);
+    ctor
+  }
+}
+
+impl<R: LeanRef> LeanIxonLetContract<R> {
+  pub fn decode(&self) -> LetContract {
+    LetContract {
+      non_dep: self.get_num_8(0) != 0,
+      kind: match self.get_num_8(1) {
+        0 => LetKind::Value,
+        1 => LetKind::BorrowShared,
+        _ => panic!("invalid Ixon.LetKind tag"),
+      },
+      binder: LeanIxonBinderContract(self.get_obj(0)).decode(),
+    }
+  }
+}
diff --git a/crates/ffi/src/lean_ixon/expr.rs b/crates/ffi/src/lean_ixon/expr.rs
index 574b32b3a..94becd760 100644
--- a/crates/ffi/src/lean_ixon/expr.rs
+++ b/crates/ffi/src/lean_ixon/expr.rs
@@ -2,8 +2,11 @@
 
 use std::sync::Arc;
 
-use crate::lean::LeanIxonExpr;
-use ixon::expr::{Expr as IxonExpr, Owned as IxonOwned, Uses as IxonUses};
+use crate::lean::{
+  LeanIxonBinderContract, LeanIxonExpr, LeanIxonLetContract,
+  LeanIxonValueContract,
+};
+use ixon::expr::Expr as IxonExpr;
 use lean_ffi::object::{LeanArray, LeanBorrowed, LeanOwned, LeanRef};
 
 /// Decode Array UInt64 from Lean.
@@ -21,7 +24,7 @@ fn decode_u64_array(obj: LeanArray<LeanBorrowed<'_>>) -> Vec<u64> {
 }
 
 impl LeanIxonExpr<LeanOwned> {
-  /// Build Ixon.Expr (12 constructors).
+  /// Build Ixon.Expr (12 constructors and wire categories).
   pub fn build(expr: &IxonExpr) -> Self {
     match expr {
       IxonExpr::Sort(idx) => {
@@ -80,34 +83,34 @@ impl LeanIxonExpr<LeanOwned> {
         ctor.set_obj(1, arg_obj);
         ctor
       },
-      IxonExpr::Lam(uses, ty, body) => {
+      IxonExpr::Lam(contract, ty, body) => {
         let ty_obj = Self::build(ty);
         let body_obj = Self::build(body);
         let ctor = LeanIxonExpr::alloc(8);
-        ctor.set_obj(0, ty_obj);
-        ctor.set_obj(1, body_obj);
-        ctor.set_num_8(0, uses.to_bits());
+        ctor.set_obj(0, LeanIxonBinderContract::build(contract));
+        ctor.set_obj(1, ty_obj);
+        ctor.set_obj(2, body_obj);
         ctor
       },
-      IxonExpr::All(uses, owned, ty, body) => {
+      IxonExpr::All(contract, result, ty, body) => {
         let ty_obj = Self::build(ty);
         let body_obj = Self::build(body);
         let ctor = LeanIxonExpr::alloc(9);
-        ctor.set_obj(0, ty_obj);
-        ctor.set_obj(1, body_obj);
-        ctor.set_num_8(0, uses.to_bits());
-        ctor.set_num_8(1, owned.to_bits());
+        ctor.set_obj(0, LeanIxonBinderContract::build(contract));
+        ctor.set_obj(1, LeanIxonValueContract::build(result));
+        ctor.set_obj(2, ty_obj);
+        ctor.set_obj(3, body_obj);
         ctor
       },
-      IxonExpr::Let(non_dep, ty, val, body) => {
+      IxonExpr::Let(contract, ty, val, body) => {
         let ty_obj = Self::build(ty);
         let val_obj = Self::build(val);
         let body_obj = Self::build(body);
         let ctor = LeanIxonExpr::alloc(10);
-        ctor.set_obj(0, ty_obj);
-        ctor.set_obj(1, val_obj);
-        ctor.set_obj(2, body_obj);
-        ctor.set_num_8(0, u8::from(*non_dep));
+        ctor.set_obj(0, LeanIxonLetContract::build(contract));
+        ctor.set_obj(1, ty_obj);
+        ctor.set_obj(2, val_obj);
+        ctor.set_obj(3, body_obj);
         ctor
       },
       IxonExpr::Share(idx) => {
@@ -129,7 +132,7 @@ impl LeanIxonExpr<LeanOwned> {
 }
 
 impl<R: LeanRef> LeanIxonExpr<R> {
-  /// Decode Ixon.Expr (12 constructors).
+  /// Decode all v3 expression forms without erasing contracts.
   pub fn decode(&self) -> IxonExpr {
     let ctor = self.as_ctor();
     let tag = ctor.tag();
@@ -174,28 +177,22 @@ impl<R: LeanRef> LeanIxonExpr<R> {
         Arc::new(LeanIxonExpr(ctor.get(1)).decode()),
       ),
       8 => IxonExpr::Lam(
-        IxonUses::from_bits(self.get_num_8(0))
-          .expect("invalid Ixon.Uses constructor tag"),
-        Arc::new(LeanIxonExpr(ctor.get(0)).decode()),
+        LeanIxonBinderContract(ctor.get(0)).decode(),
         Arc::new(LeanIxonExpr(ctor.get(1)).decode()),
+        Arc::new(LeanIxonExpr(ctor.get(2)).decode()),
       ),
       9 => IxonExpr::All(
-        IxonUses::from_bits(self.get_num_8(0))
-          .expect("invalid Ixon.Uses constructor tag"),
-        IxonOwned::from_bits(self.get_num_8(1))
-          .expect("invalid Ixon.Owned constructor tag"),
-        Arc::new(LeanIxonExpr(ctor.get(0)).decode()),
-        Arc::new(LeanIxonExpr(ctor.get(1)).decode()),
+        LeanIxonBinderContract(ctor.get(0)).decode(),
+        LeanIxonValueContract(ctor.get(1)).decode(),
+        Arc::new(LeanIxonExpr(ctor.get(2)).decode()),
+        Arc::new(LeanIxonExpr(ctor.get(3)).decode()),
+      ),
+      10 => IxonExpr::Let(
+        LeanIxonLetContract(ctor.get(0)).decode(),
+        Arc::new(LeanIxonExpr(self.get_obj(1)).decode()),
+        Arc::new(LeanIxonExpr(self.get_obj(2)).decode()),
+        Arc::new(LeanIxonExpr(self.get_obj(3)).decode()),
       ),
-      10 => {
-        let non_dep = self.get_num_8(0) != 0;
-        IxonExpr::Let(
-          non_dep,
-          Arc::new(LeanIxonExpr(self.get_obj(0)).decode()),
-          Arc::new(LeanIxonExpr(self.get_obj(1)).decode()),
-          Arc::new(LeanIxonExpr(self.get_obj(2)).decode()),
-        )
-      },
       11 => {
         let idx = self.get_num_64(0);
         IxonExpr::Share(idx)
diff --git a/crates/ixon/src/catalog.rs b/crates/ixon/src/catalog.rs
index 474a91d99..befec4f15 100644
--- a/crates/ixon/src/catalog.rs
+++ b/crates/ixon/src/catalog.rs
@@ -64,8 +64,8 @@ pub const CATALOG_MAGIC: &[u8; 8] = b"IXC\0\0\0\0\0";
 /// The manifest's filename inside a `.ixc` directory.
 pub const MANIFEST_FILE: &str = "manifest";
 
-/// `.ixc` format version.
-pub const CATALOG_VERSION: u32 = 1;
+/// Manifest v2 binds Ixon v3 and erased-lean-v1 catalog claims.
+pub const CATALOG_VERSION: u32 = 2;
 
 /// Storage-profile flag: bit0 of the header `flags` word.
 pub const FLAG_CHUNKED: u32 = 1;
@@ -228,6 +228,7 @@ impl Catalog {
     out.extend_from_slice(&CATALOG_VERSION.to_le_bytes());
     let flags: u32 = if self.is_chunked() { FLAG_CHUNKED } else { 0 };
     out.extend_from_slice(&flags.to_le_bytes());
+    out.extend_from_slice(&[3, 1]); // Ixon v3, erased-lean-v1.
     out.extend_from_slice(self.members_root.as_bytes());
     out.extend_from_slice(self.content_root.as_bytes());
     let count = u32::try_from(self.members.len())
@@ -306,6 +307,12 @@ impl Catalog {
       // they may change the meaning of everything that follows.
       return Err(format!("unknown .ixc flags 0x{flags:X}"));
     }
+    if c.u8()? != 3 {
+      return Err("catalog: unsupported object format".into());
+    }
+    if c.u8()? != 1 {
+      return Err("catalog: wrong validator identity".into());
+    }
     let members_root = c.addr()?;
     let content_root = c.addr()?;
     let member_count = c.u32()? as usize;
@@ -1126,9 +1133,17 @@ mod tests {
     bad[12] |= 0x02;
     assert!(Catalog::from_bytes(&bad).unwrap_err().contains("flags"));
 
+    for (offset, value, message) in
+      [(8, 1, "version"), (16, 2, "format"), (17, 2, "validator")]
+    {
+      let mut bad = good.clone();
+      bad[offset] = value;
+      assert!(Catalog::from_bytes(&bad).unwrap_err().contains(message));
+    }
+
     // Flipped member env root breaks the recomputed members_root.
     let mut bad = good.clone();
-    let member_root_off = 8 + 4 + 4 + 32 + 32 + 4;
+    let member_root_off = 8 + 4 + 4 + 2 + 32 + 32 + 4;
     bad[member_root_off] ^= 0xFF;
     assert!(Catalog::from_bytes(&bad).unwrap_err().contains("members_root"));
 
diff --git a/crates/ixon/src/contract.rs b/crates/ixon/src/contract.rs
new file mode 100644
index 000000000..392fa3b0d
--- /dev/null
+++ b/crates/ixon/src/contract.rs
@@ -0,0 +1,231 @@
+//! Independent usage, ownership, and relative-locality contracts.
+
+use crate::expr::{Owned, Uses};
+use crate::serialize::get_u8;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+#[repr(u8)]
+pub enum Locality {
+  #[default]
+  Unrestricted = 0,
+  Local = 1,
+}
+
+impl Locality {
+  pub const fn to_bits(self) -> u8 {
+    self as u8
+  }
+  pub const fn from_bits(bits: u8) -> Option<Self> {
+    match bits {
+      0 => Some(Self::Unrestricted),
+      1 => Some(Self::Local),
+      _ => None,
+    }
+  }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct ValueContract {
+  pub owned: Owned,
+  pub locality: Locality,
+}
+
+impl Default for ValueContract {
+  fn default() -> Self {
+    Self::shared()
+  }
+}
+
+impl ValueContract {
+  pub const fn shared() -> Self {
+    Self { owned: Owned::Shared, locality: Locality::Unrestricted }
+  }
+  pub const fn unique() -> Self {
+    Self { owned: Owned::Unique, locality: Locality::Unrestricted }
+  }
+  pub const fn local_shared() -> Self {
+    Self { owned: Owned::Shared, locality: Locality::Local }
+  }
+  pub const fn local_unique() -> Self {
+    Self { owned: Owned::Unique, locality: Locality::Local }
+  }
+  pub const fn to_bits(self) -> u8 {
+    self.owned.to_bits() | (self.locality.to_bits() << 1)
+  }
+  pub fn from_bits(bits: u8) -> Option<Self> {
+    if bits > 3 {
+      return None;
+    }
+    Some(Self {
+      owned: Owned::from_bits(bits & 1)?,
+      locality: Locality::from_bits(bits >> 1)?,
+    })
+  }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct BinderContract {
+  pub uses: Uses,
+  pub value: ValueContract,
+}
+
+impl Default for BinderContract {
+  fn default() -> Self {
+    Self::plain(Uses::Many)
+  }
+}
+
+impl BinderContract {
+  pub const fn plain(uses: Uses) -> Self {
+    Self { uses, value: ValueContract::shared() }
+  }
+  pub const fn to_bits(self) -> u8 {
+    self.uses.to_bits() | (self.value.to_bits() << 2)
+  }
+  pub fn from_bits(bits: u8) -> Option<Self> {
+    if bits > 15 {
+      return None;
+    }
+    Some(Self {
+      uses: Uses::from_bits(bits & 3)?,
+      value: ValueContract::from_bits(bits >> 2)?,
+    })
+  }
+}
+
+pub const fn pack_all_contract(
+  input: BinderContract,
+  result: ValueContract,
+) -> u8 {
+  input.to_bits() | (result.to_bits() << 4)
+}
+
+pub fn unpack_all_contract(
+  bits: u8,
+) -> Option<(BinderContract, ValueContract)> {
+  if bits > 63 {
+    return None;
+  }
+  Some((
+    BinderContract::from_bits(bits & 15)?,
+    ValueContract::from_bits(bits >> 4)?,
+  ))
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+#[repr(u8)]
+pub enum LetKind {
+  #[default]
+  Value = 0,
+  BorrowShared = 1,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct LetContract {
+  pub non_dep: bool,
+  pub kind: LetKind,
+  pub binder: BinderContract,
+}
+
+impl LetContract {
+  pub const fn plain(non_dep: bool) -> Self {
+    Self {
+      non_dep,
+      kind: LetKind::Value,
+      binder: BinderContract::plain(Uses::Many),
+    }
+  }
+  pub const fn borrow(non_dep: bool, uses: Uses) -> Self {
+    Self {
+      non_dep,
+      kind: LetKind::BorrowShared,
+      binder: BinderContract { uses, value: ValueContract::local_shared() },
+    }
+  }
+  pub const fn flags(self) -> u64 {
+    (self.non_dep as u64) | ((self.kind as u64) << 1)
+  }
+  pub fn from_flags(flags: u64, binder: BinderContract) -> Option<Self> {
+    if flags > 3 {
+      return None;
+    }
+    Some(Self {
+      non_dep: flags & 1 == 1,
+      kind: if flags & 2 == 2 { LetKind::BorrowShared } else { LetKind::Value },
+      binder,
+    })
+  }
+}
+
+pub fn put_value_contract(value: &ValueContract, buf: &mut Vec<u8>) {
+  buf.push(value.to_bits());
+}
+
+pub fn get_value_contract(buf: &mut &[u8]) -> Result<ValueContract, String> {
+  let bits = get_u8(buf)?;
+  ValueContract::from_bits(bits)
+    .ok_or_else(|| format!("invalid value contract {bits}"))
+}
+
+pub fn put_binder_contract(binder: &BinderContract, buf: &mut Vec<u8>) {
+  buf.push(binder.to_bits());
+}
+
+pub fn get_binder_contract(buf: &mut &[u8]) -> Result<BinderContract, String> {
+  let bits = get_u8(buf)?;
+  BinderContract::from_bits(bits)
+    .ok_or_else(|| format!("invalid binder contract {bits}"))
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn independent_modes_have_canonical_codes() {
+    let values = [
+      ValueContract::unique(),
+      ValueContract::shared(),
+      ValueContract::local_unique(),
+      ValueContract::local_shared(),
+    ];
+    let uses = [Uses::Erased, Uses::Linear, Uses::Affine, Uses::Many];
+    for (value_code, value) in values.into_iter().enumerate() {
+      assert_eq!(value.to_bits(), u8::try_from(value_code).unwrap());
+      assert_eq!(
+        ValueContract::from_bits(u8::try_from(value_code).unwrap()),
+        Some(value)
+      );
+      for (use_code, uses) in uses.into_iter().enumerate() {
+        let binder = BinderContract { uses, value };
+        let code = u8::try_from(use_code).unwrap()
+          + 4 * u8::try_from(value_code).unwrap();
+        assert_eq!(binder.to_bits(), code);
+        assert_eq!(BinderContract::from_bits(code), Some(binder));
+        for (result_code, result) in values.into_iter().enumerate() {
+          let all_code = code + 16 * u8::try_from(result_code).unwrap();
+          assert_eq!(pack_all_contract(binder, result), all_code);
+          assert_eq!(unpack_all_contract(all_code), Some((binder, result)));
+        }
+        for flags in 0..4 {
+          let let_contract = LetContract::from_flags(flags, binder).unwrap();
+          assert_eq!(let_contract.flags(), flags);
+          assert_eq!(let_contract.binder, binder);
+        }
+      }
+    }
+    for code in 4..=u8::MAX {
+      assert!(ValueContract::from_bits(code).is_none());
+    }
+    for code in 16..=u8::MAX {
+      assert!(BinderContract::from_bits(code).is_none());
+    }
+    for code in 64..=u8::MAX {
+      assert!(unpack_all_contract(code).is_none());
+    }
+    assert!(LetContract::from_flags(4, BinderContract::default()).is_none());
+    assert!(
+      LetContract::from_flags(u64::MAX, BinderContract::default()).is_none()
+    );
+  }
+}
diff --git a/crates/ixon/src/expr.rs b/crates/ixon/src/expr.rs
index 0ec3544f9..0aee6c4a2 100644
--- a/crates/ixon/src/expr.rs
+++ b/crates/ixon/src/expr.rs
@@ -3,9 +3,10 @@
 #![allow(clippy::cast_possible_truncation)]
 #![allow(clippy::needless_pass_by_value)]
 
+use crate::contract::{BinderContract, LetContract, Locality, ValueContract};
 use std::sync::Arc;
 
-/// Binder usage carried by Ixon v2 lambda and forall nodes.
+/// Computational usage, independent of ownership and locality.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[repr(u8)]
 pub enum Uses {
@@ -31,7 +32,7 @@ impl Uses {
   }
 }
 
-/// Ownership made available to the caller for a forall result.
+/// Ownership of a bound or returned value, independent of usage and locality.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 #[repr(u8)]
 pub enum Owned {
@@ -78,12 +79,12 @@ pub enum Expr {
   Nat(u64),
   /// Application: (function, argument)
   App(Arc<Expr>, Arc<Expr>),
-  /// Lambda: (binder_usage, binder_type, body)
-  Lam(Uses, Arc<Expr>, Arc<Expr>),
-  /// Forall/Pi: (binder_usage, result_ownership, binder_type, body)
-  All(Uses, Owned, Arc<Expr>, Arc<Expr>),
-  /// Let: (non_dep, type, value, body)
-  Let(bool, Arc<Expr>, Arc<Expr>, Arc<Expr>),
+  /// Lambda: (input contract, binder type, body)
+  Lam(BinderContract, Arc<Expr>, Arc<Expr>),
+  /// Forall/Pi: (input contract, independent result contract, domain, body)
+  All(BinderContract, ValueContract, Arc<Expr>, Arc<Expr>),
+  /// Ordinary let: (dependency/input contract, type, value, body)
+  Let(LetContract, Arc<Expr>, Arc<Expr>, Arc<Expr>),
   /// Reference to shared subexpression in MutualBlock.sharing[idx]
   Share(u64),
 }
@@ -100,7 +101,7 @@ impl Expr {
   pub const FLAG_APP: u8 = 0x7;
   pub const FLAG_LAM: u8 = 0x8;
   pub const FLAG_ALL: u8 = 0x9;
-  pub const FLAG_LET: u8 = 0xA; // size=0 for dep, size=1 for non_dep
+  pub const FLAG_LET: u8 = 0xA; // size holds dependency and borrow flags
   pub const FLAG_SHARE: u8 = 0xB;
 
   pub fn sort(univ_idx: u64) -> Arc<Self> {
@@ -140,7 +141,15 @@ impl Expr {
   }
 
   pub fn lam_mode(uses: Uses, ty: Arc<Expr>, body: Arc<Expr>) -> Arc<Self> {
-    Arc::new(Expr::Lam(uses, ty, body))
+    Self::lam_contract(BinderContract::plain(uses), ty, body)
+  }
+
+  pub fn lam_contract(
+    contract: BinderContract,
+    ty: Arc<Expr>,
+    body: Arc<Expr>,
+  ) -> Arc<Self> {
+    Arc::new(Expr::Lam(contract, ty, body))
   }
 
   pub fn all(ty: Arc<Expr>, body: Arc<Expr>) -> Arc<Self> {
@@ -153,7 +162,21 @@ impl Expr {
     ty: Arc<Expr>,
     body: Arc<Expr>,
   ) -> Arc<Self> {
-    Arc::new(Expr::All(uses, owned, ty, body))
+    Self::all_contract(
+      BinderContract::plain(uses),
+      ValueContract { owned, locality: Locality::Unrestricted },
+      ty,
+      body,
+    )
+  }
+
+  pub fn all_contract(
+    contract: BinderContract,
+    result: ValueContract,
+    ty: Arc<Expr>,
+    body: Arc<Expr>,
+  ) -> Arc<Self> {
+    Arc::new(Expr::All(contract, result, ty, body))
   }
 
   pub fn let_(
@@ -162,13 +185,70 @@ impl Expr {
     val: Arc<Expr>,
     body: Arc<Expr>,
   ) -> Arc<Self> {
-    Arc::new(Expr::Let(non_dep, ty, val, body))
+    Self::let_contract(LetContract::plain(non_dep), ty, val, body)
+  }
+
+  pub fn let_contract(
+    contract: LetContract,
+    ty: Arc<Expr>,
+    val: Arc<Expr>,
+    body: Arc<Expr>,
+  ) -> Arc<Self> {
+    Arc::new(Expr::Let(contract, ty, val, body))
   }
 
   pub fn share(idx: u64) -> Arc<Self> {
     Arc::new(Expr::Share(idx))
   }
 
+  /// Direct expression children, preserving contracts on their parent.
+  pub fn children(&self) -> Vec<&Arc<Self>> {
+    match self {
+      Self::Sort(_)
+      | Self::Var(_)
+      | Self::Ref(..)
+      | Self::Rec(..)
+      | Self::Str(_)
+      | Self::Nat(_)
+      | Self::Share(_) => vec![],
+      Self::Prj(_, _, e) => vec![e],
+      Self::App(a, b) | Self::Lam(_, a, b) | Self::All(_, _, a, b) => {
+        vec![a, b]
+      },
+      Self::Let(_, a, b, c) => vec![a, b, c],
+    }
+  }
+
+  /// Rebuild a node without dropping any scalar or contract field.
+  pub fn with_children(&self, children: &[Arc<Self>]) -> Result<Self, String> {
+    if self.children().len() != children.len() {
+      return Err("expression reconstruction child count mismatch".into());
+    }
+    Ok(match self {
+      Self::Sort(_)
+      | Self::Var(_)
+      | Self::Ref(..)
+      | Self::Rec(..)
+      | Self::Str(_)
+      | Self::Nat(_)
+      | Self::Share(_) => self.clone(),
+      Self::Prj(t, f, _) => Self::Prj(*t, *f, children[0].clone()),
+      Self::App(..) => Self::App(children[0].clone(), children[1].clone()),
+      Self::Lam(c, ..) => {
+        Self::Lam(*c, children[0].clone(), children[1].clone())
+      },
+      Self::All(c, v, ..) => {
+        Self::All(*c, *v, children[0].clone(), children[1].clone())
+      },
+      Self::Let(c, ..) => Self::Let(
+        *c,
+        children[0].clone(),
+        children[1].clone(),
+        children[2].clone(),
+      ),
+    })
+  }
+
   /// Count nested applications for telescope compression.
   pub fn app_telescope_count(&self) -> u64 {
     let mut count = 0u64;
@@ -229,6 +309,21 @@ pub mod tests {
     Let,
   }
 
+  fn arbitrary_value_contract(g: &mut Gen) -> ValueContract {
+    ValueContract {
+      owned: if bool::arbitrary(g) { Owned::Unique } else { Owned::Shared },
+      locality: if bool::arbitrary(g) {
+        Locality::Local
+      } else {
+        Locality::Unrestricted
+      },
+    }
+  }
+
+  fn arbitrary_binder_contract(g: &mut Gen, uses: Uses) -> BinderContract {
+    BinderContract { uses, value: arbitrary_value_contract(g) }
+  }
+
   /// Generate an arbitrary Expr using pointer-tree technique (no stack overflow)
   pub fn arbitrary_expr(g: &mut Gen) -> Arc<Expr> {
     use crate::tests::next_case;
@@ -314,7 +409,10 @@ pub mod tests {
             Arc::get_mut(&mut body).unwrap() as *mut Expr,
           );
           unsafe {
-            ptr::write(ptr, Expr::Lam(uses, ty, body));
+            ptr::write(
+              ptr,
+              Expr::Lam(arbitrary_binder_contract(g, uses), ty, body),
+            );
           }
           stack.push(body_ptr);
           stack.push(ty_ptr);
@@ -326,8 +424,6 @@ pub mod tests {
             2 => Uses::Affine,
             _ => Uses::Many,
           };
-          let owned =
-            if gen_range(g, 0..2) == 0 { Owned::Unique } else { Owned::Shared };
           let mut ty = Arc::new(Expr::Var(0));
           let mut body = Arc::new(Expr::Var(0));
           let (ty_ptr, body_ptr) = (
@@ -335,7 +431,15 @@ pub mod tests {
             Arc::get_mut(&mut body).unwrap() as *mut Expr,
           );
           unsafe {
-            ptr::write(ptr, Expr::All(uses, owned, ty, body));
+            ptr::write(
+              ptr,
+              Expr::All(
+                arbitrary_binder_contract(g, uses),
+                arbitrary_value_contract(g),
+                ty,
+                body,
+              ),
+            );
           }
           stack.push(body_ptr);
           stack.push(ty_ptr);
@@ -351,6 +455,7 @@ pub mod tests {
           stack.push(val_ptr);
         },
         Case::Let => {
+          let uses = Uses::from_bits(gen_range(g, 0..4) as u8).unwrap();
           let mut ty = Arc::new(Expr::Var(0));
           let mut val = Arc::new(Expr::Var(0));
           let mut body = Arc::new(Expr::Var(0));
@@ -360,7 +465,23 @@ pub mod tests {
             Arc::get_mut(&mut body).unwrap() as *mut Expr,
           );
           unsafe {
-            ptr::write(ptr, Expr::Let(bool::arbitrary(g), ty, val, body));
+            ptr::write(
+              ptr,
+              Expr::Let(
+                LetContract {
+                  non_dep: bool::arbitrary(g),
+                  kind: if bool::arbitrary(g) {
+                    crate::contract::LetKind::BorrowShared
+                  } else {
+                    crate::contract::LetKind::Value
+                  },
+                  binder: arbitrary_binder_contract(g, uses),
+                },
+                ty,
+                val,
+                body,
+              ),
+            );
           }
           stack.push(body_ptr);
           stack.push(val_ptr);
diff --git a/crates/ixon/src/lib.rs b/crates/ixon/src/lib.rs
index 4a9ce3be3..aeff352d1 100644
--- a/crates/ixon/src/lib.rs
+++ b/crates/ixon/src/lib.rs
@@ -11,6 +11,7 @@ pub mod canon_univ;
 pub mod catalog;
 pub mod comm;
 pub mod constant;
+pub mod contract;
 #[cfg(not(target_arch = "riscv64"))]
 pub mod diff;
 pub mod env;
@@ -21,6 +22,7 @@ pub mod map;
 pub mod merkle;
 pub mod metadata;
 pub mod proof;
+pub mod resource;
 pub mod serialize;
 pub mod shard_claim;
 pub mod sharing;
@@ -28,8 +30,8 @@ pub mod syntax;
 pub mod tag;
 pub mod univ;
 
-/// Stable identifier for the v2 Ixon wire grammar.
-pub const WIRE_FORMAT_ID: &str = "ixon-v2";
+/// Stable identifier for the v3 Ixon wire grammar.
+pub const WIRE_FORMAT_ID: &str = "ixon-v3";
 
 // Re-export main types
 pub use comm::Comm;
@@ -285,7 +287,6 @@ mod doc_examples {
   fn expr_app_telescope() {
     // App(App(App(f, a), b), c) with f=Var(3), a=Var(2), b=Var(1), c=Var(0)
     // -> Tag4 { flag: 0x7, size: 3 } + f + a + b + c
-    // = 0x73 + 0x13 + 0x12 + 0x11 + 0x10
     let expr = Expr::app(
       Expr::app(Expr::app(Expr::var(3), Expr::var(2)), Expr::var(1)),
       Expr::var(0),
@@ -295,16 +296,15 @@ mod doc_examples {
     assert_eq!(
       buf,
       vec![0x73, 0x13, 0x12, 0x11, 0x10],
-      "App telescope should be [0x73, 0x13, 0x12, 0x11, 0x10]"
+      "App telescope contains its ordinary arguments"
     );
   }
 
   #[test]
   fn expr_lam_telescope() {
     // Lam(t1, Lam(t2, Lam(t3, body))) with all types Sort(0) and body Var(0)
-    // -> Tag4 { flag: 0x8, size: 3 } + (many, t1) + (many, t2)
-    //    + (many, t3) + body
-    // = 0x83 + 0x03 + 0x00 + 0x03 + 0x00 + 0x03 + 0x00 + 0x10
+    // Each binder uses one byte: many (3), shared (bit 2), unrestricted.
+    // Its domain follows; the body follows all three binders.
     let ty = Expr::sort(0);
     let expr = Expr::lam(
       ty.clone(),
@@ -314,8 +314,8 @@ mod doc_examples {
     serialize::put_expr(&expr, &mut buf);
     assert_eq!(
       buf,
-      vec![0x83, 0x03, 0x00, 0x03, 0x00, 0x03, 0x00, 0x10],
-      "Lam telescope should carry one v2 mode byte per binder"
+      vec![0x83, 0x07, 0x00, 0x07, 0x00, 0x07, 0x00, 0x10],
+      "Lam telescope carries explicit v3 input contracts"
     );
   }
 
@@ -335,7 +335,7 @@ mod doc_examples {
     claim.put(&mut buf);
     assert_eq!(buf[0], 0xE3, "Eval claim should start with 0xE3");
     // 1 (tag) + 64 (addresses) + 1 (opt=None) = 66
-    assert_eq!(buf.len(), 1 + 64 + 1, "Eval claim no-asm = 66 bytes");
+    assert_eq!(buf.len(), 1 + 2 + 64 + 1, "Eval claim no-asm = 68 bytes");
   }
 
   #[test]
@@ -353,9 +353,9 @@ mod doc_examples {
     proof.put(&mut buf);
     assert_eq!(buf[0], 0xF0, "Eval proof should start with 0xF0");
     // 1 (tag) + 64 (addresses) + 1 (opt) + 1 (len=4) + 4 (proof) = 71
-    assert_eq!(buf.len(), 71, "Eval proof no-asm + 4 proof bytes = 71 bytes");
-    assert_eq!(buf[66], 0x04, "proof.len byte should be 0x04");
-    assert_eq!(&buf[67..71], &[1, 2, 3, 4], "proof bytes should be [1,2,3,4]");
+    assert_eq!(buf.len(), 73, "Eval proof no-asm + 4 proof bytes = 73 bytes");
+    assert_eq!(buf[68], 0x04, "proof.len byte should be 0x04");
+    assert_eq!(&buf[69..73], &[1, 2, 3, 4], "proof bytes should be [1,2,3,4]");
   }
 
   #[test]
@@ -366,7 +366,7 @@ mod doc_examples {
     let mut buf = Vec::new();
     claim.put(&mut buf);
     assert_eq!(buf[0], 0xE4, "Check claim should start with 0xE4");
-    assert_eq!(buf.len(), 1 + 32 + 1, "Check claim no-asm = 34 bytes");
+    assert_eq!(buf.len(), 1 + 2 + 32 + 1, "Check claim no-asm = 36 bytes");
   }
 
   #[test]
@@ -493,7 +493,7 @@ mod doc_examples {
 
   #[test]
   fn env_tag() {
-    // Env -> Tag4 { flag: 0xE, size: VERSION } -> 0xE2 for v2
+    // Env -> Tag4 { flag: 0xE, size: VERSION } -> 0xE3 for v3
     let env = Env::new();
     let mut buf = Vec::new();
     env.put(&mut buf).unwrap();
diff --git a/crates/ixon/src/proof.rs b/crates/ixon/src/proof.rs
index efe3cc9d3..05a27e702 100644
--- a/crates/ixon/src/proof.rs
+++ b/crates/ixon/src/proof.rs
@@ -174,6 +174,8 @@ pub enum Claim {
   /// shard protocol one level up) — there is deliberately no
   /// whole-catalog interpreter arm.
   Catalog { members: Address, content: Address, assumptions: Option<Address> },
+  /// Combined erased typing and resource admission of a complete addressed closure.
+  Resource { root: Address, profile: Address },
 }
 
 /// A proof of a claim.
@@ -217,6 +219,7 @@ pub const VARIANT_CHECK_ENV_CLAIM: u64 = 5;
 pub const VARIANT_REVEAL_CLAIM: u64 = 6;
 pub const VARIANT_CONTAINS_CLAIM: u64 = 7;
 pub const VARIANT_CATALOG_CLAIM: u64 = 8;
+pub const VARIANT_RESOURCE_CLAIM: u64 = 9;
 
 /// Tag4 flag for ZK proofs (0xF). All variants in single-byte tags
 /// (`0xF0`–`0xF5`). Slots 6-7 reserved for future proof variants.
@@ -239,6 +242,7 @@ pub const VARIANT_CHECK_ENV_PROOF: u64 = 2;
 pub const VARIANT_REVEAL_PROOF: u64 = 3;
 pub const VARIANT_CONTAINS_PROOF: u64 = 4;
 pub const VARIANT_CATALOG_PROOF: u64 = 5;
+pub const VARIANT_RESOURCE_PROOF: u64 = 6;
 
 // Backwards-compatibility re-export: many call sites refer to FLAG.
 pub const FLAG: u8 = FLAG_CLAIM;
@@ -943,42 +947,62 @@ fn get_opt_addr(buf: &mut &[u8]) -> Result<Option<Address>, String> {
   }
 }
 
+fn validator_for_variant(variant: u64) -> u8 {
+  match variant {
+    VARIANT_REVEAL_CLAIM | VARIANT_CONTAINS_CLAIM => 0,
+    VARIANT_RESOURCE_CLAIM => 2,
+    _ => 1,
+  }
+}
+fn put_scope(validator: u8, buf: &mut Vec<u8>) {
+  buf.extend_from_slice(&[3, validator]);
+}
+fn get_scope(validator: u8, buf: &mut &[u8]) -> Result<(), String> {
+  if get_u8(buf)? != 3 {
+    return Err("claim: unsupported object format".into());
+  }
+  if get_u8(buf)? != validator {
+    return Err("claim: wrong validator identity".into());
+  }
+  Ok(())
+}
+
 impl Claim {
   pub fn put(&self, buf: &mut Vec<u8>) {
+    Tag4::new(FLAG_CLAIM, self.proof_variant_size() + 3).put(buf);
+    put_scope(validator_for_variant(self.proof_variant_size() + 3), buf);
     match self {
       Claim::Eval { input, output, assumptions } => {
-        Tag4::new(FLAG_CLAIM, VARIANT_EVAL_CLAIM).put(buf);
         buf.extend_from_slice(input.as_bytes());
         buf.extend_from_slice(output.as_bytes());
         put_opt_addr(assumptions, buf);
       },
       Claim::Check { const_addr, assumptions } => {
-        Tag4::new(FLAG_CLAIM, VARIANT_CHECK_CLAIM).put(buf);
         buf.extend_from_slice(const_addr.as_bytes());
         put_opt_addr(assumptions, buf);
       },
       Claim::CheckEnv { root, assumptions } => {
-        Tag4::new(FLAG_CLAIM, VARIANT_CHECK_ENV_CLAIM).put(buf);
         buf.extend_from_slice(root.as_bytes());
         put_opt_addr(assumptions, buf);
       },
       Claim::Reveal { comm, info } => {
-        Tag4::new(FLAG_CLAIM, VARIANT_REVEAL_CLAIM).put(buf);
         buf.extend_from_slice(comm.as_bytes());
         info.put(buf);
       },
       Claim::Contains { tree, const_addr } => {
-        Tag4::new(FLAG_CLAIM, VARIANT_CONTAINS_CLAIM).put(buf);
         buf.extend_from_slice(tree.as_bytes());
         buf.extend_from_slice(const_addr.as_bytes());
       },
       Claim::Catalog { members, content, assumptions } => {
         // First multi-byte claim tag: 0xE8 0x08 on the wire.
-        Tag4::new(FLAG_CLAIM, VARIANT_CATALOG_CLAIM).put(buf);
         buf.extend_from_slice(members.as_bytes());
         buf.extend_from_slice(content.as_bytes());
         put_opt_addr(assumptions, buf);
       },
+      Claim::Resource { root, profile } => {
+        buf.extend_from_slice(root.as_bytes());
+        buf.extend_from_slice(profile.as_bytes());
+      },
     }
   }
 
@@ -990,6 +1014,7 @@ impl Claim {
         FLAG_CLAIM, tag.flag
       ));
     }
+    get_scope(validator_for_variant(tag.size), buf)?;
     match tag.size {
       VARIANT_EVAL_CLAIM => {
         let input = get_address(buf)?;
@@ -1023,12 +1048,25 @@ impl Claim {
         let assumptions = get_opt_addr(buf)?;
         Ok(Claim::Catalog { members, content, assumptions })
       },
+      VARIANT_RESOURCE_CLAIM => Ok(Claim::Resource {
+        root: get_address(buf)?,
+        profile: get_address(buf)?,
+      }),
       x => {
         Err(format!("Claim::get: invalid claim variant {x} under flag 0xE",))
       },
     }
   }
 
+  pub fn from_bytes(bytes: &[u8]) -> Result<Self, String> {
+    let mut rest = bytes;
+    let claim = Self::get(&mut rest)?;
+    if !rest.is_empty() {
+      return Err("claim: trailing bytes".into());
+    }
+    Ok(claim)
+  }
+
   /// Serialize a claim and compute its content address.
   pub fn commit(&self) -> (Address, Vec<u8>) {
     let mut buf = Vec::new();
@@ -1046,6 +1084,7 @@ impl Claim {
       Claim::Reveal { .. } => VARIANT_REVEAL_PROOF,
       Claim::Contains { .. } => VARIANT_CONTAINS_PROOF,
       Claim::Catalog { .. } => VARIANT_CATALOG_PROOF,
+      Claim::Resource { .. } => VARIANT_RESOURCE_PROOF,
     }
   }
 }
@@ -1064,6 +1103,7 @@ impl Proof {
     // Proofs live under flag 0xF; claim payload is the same body as the
     // matching Claim variant.
     Tag4::new(FLAG_PROOF, proof_size).put(buf);
+    put_scope(validator_for_variant(proof_size + 3), buf);
     match &self.claim {
       Claim::Eval { input, output, assumptions } => {
         buf.extend_from_slice(input.as_bytes());
@@ -1091,6 +1131,10 @@ impl Proof {
         buf.extend_from_slice(content.as_bytes());
         put_opt_addr(assumptions, buf);
       },
+      Claim::Resource { root, profile } => {
+        buf.extend_from_slice(root.as_bytes());
+        buf.extend_from_slice(profile.as_bytes());
+      },
     }
     // Opaque ZK proof bytes: length prefix + data
     Tag0::new(self.proof.len() as u64).put(buf);
@@ -1105,6 +1149,7 @@ impl Proof {
         FLAG_PROOF, tag.flag
       ));
     }
+    get_scope(validator_for_variant(tag.size.wrapping_add(3)), buf)?;
     let claim = match tag.size {
       VARIANT_EVAL_PROOF => {
         let input = get_address(buf)?;
@@ -1138,6 +1183,9 @@ impl Proof {
         let assumptions = get_opt_addr(buf)?;
         Claim::Catalog { members, content, assumptions }
       },
+      VARIANT_RESOURCE_PROOF => {
+        Claim::Resource { root: get_address(buf)?, profile: get_address(buf)? }
+      },
       x => {
         return Err(format!(
           "Proof::get: invalid proof variant {x} under flag 0xF"
@@ -1374,7 +1422,7 @@ mod tests {
 
   impl Arbitrary for Claim {
     fn arbitrary(g: &mut Gen) -> Self {
-      match u8::arbitrary(g) % 6 {
+      match u8::arbitrary(g) % 7 {
         0 => Claim::Eval {
           input: Address::arbitrary(g),
           output: Address::arbitrary(g),
@@ -1397,6 +1445,10 @@ mod tests {
           content: Address::arbitrary(g),
           assumptions: gen_opt_addr(g),
         },
+        5 => Claim::Resource {
+          root: Address::arbitrary(g),
+          profile: Address::arbitrary(g),
+        },
         _ => Claim::Contains {
           tree: Address::arbitrary(g),
           const_addr: Address::arbitrary(g),
@@ -1455,7 +1507,7 @@ mod tests {
       assumptions: Some(asm.clone()),
     };
     let (addr, bytes) = claim.commit();
-    let mut expected = vec![0xE8, 0x08];
+    let mut expected = vec![0xE8, 0x08, 3, 1];
     expected.extend_from_slice(members.as_bytes());
     expected.extend_from_slice(content.as_bytes());
     expected.push(0x01);
@@ -1467,14 +1519,14 @@ mod tests {
     // two serializers cannot drift on the large-tag path unnoticed.
     assert_eq!(
       addr.hex(),
-      "608af1f5477517d14427da664ae7a62d46cd9236b2183481c7801910683579bf",
+      "1ae7fec8efde892b6b540888df70d53977a264bbc84be300d4335ce04c916072",
       "catalog claim digest drifted"
     );
     // Unconditional form: trailing 0x00, same 2-byte tag.
     let claim_none = Claim::Catalog { members, content, assumptions: None };
     let mut buf = Vec::new();
     claim_none.put(&mut buf);
-    assert_eq!(buf.len(), 2 + 32 + 32 + 1);
+    assert_eq!(buf.len(), 2 + 2 + 32 + 32 + 1);
     assert_eq!(&buf[0..2], &[0xE8, 0x08]);
     assert_eq!(*buf.last().unwrap(), 0x00);
     // The proof wrapper stays a single-byte tag: 0xF5.
@@ -1815,8 +1867,8 @@ mod tests {
         assumptions: None
       })
       .len(),
-      1 + 64 + 1,
-      "Eval no-asm = 66 bytes"
+      1 + 2 + 64 + 1,
+      "Eval no-asm = 68 bytes"
     );
     assert_eq!(
       claim_bytes(&Claim::Eval {
@@ -1825,14 +1877,14 @@ mod tests {
         assumptions: Some(asm.clone())
       })
       .len(),
-      1 + 64 + 1 + 32,
-      "Eval with-asm = 98 bytes"
+      1 + 2 + 64 + 1 + 32,
+      "Eval with-asm = 100 bytes"
     );
     assert_eq!(
       claim_bytes(&Claim::Check { const_addr: a.clone(), assumptions: None })
         .len(),
-      1 + 32 + 1,
-      "Check no-asm = 34 bytes"
+      1 + 2 + 32 + 1,
+      "Check no-asm = 36 bytes"
     );
     assert_eq!(
       claim_bytes(&Claim::Check {
@@ -1840,19 +1892,19 @@ mod tests {
         assumptions: Some(asm.clone())
       })
       .len(),
-      1 + 32 + 1 + 32,
-      "Check with-asm = 66 bytes"
+      1 + 2 + 32 + 1 + 32,
+      "Check with-asm = 68 bytes"
     );
     assert_eq!(
       claim_bytes(&Claim::CheckEnv { root: a.clone(), assumptions: None })
         .len(),
-      1 + 32 + 1,
-      "CheckEnv no-asm = 34 bytes"
+      1 + 2 + 32 + 1,
+      "CheckEnv no-asm = 36 bytes"
     );
     assert_eq!(
       claim_bytes(&Claim::Contains { tree: a, const_addr: b }).len(),
-      1 + 64,
-      "Contains = 65 bytes"
+      1 + 2 + 64,
+      "Contains = 67 bytes"
     );
   }
 
@@ -1933,11 +1985,11 @@ mod tests {
     let mut buf = Vec::new();
     claim.put(&mut buf);
     assert_eq!(buf[0], 0xE6); // Tag4: flag=0xE, size=6 (Reveal claim)
-    // buf[1..33] = comm_addr (32 bytes)
-    assert_eq!(buf[33], 0x00); // RevealConstantInfo variant: Definition
-    assert_eq!(buf[34], 0x02); // mask: bit 1 (safety)
-    assert_eq!(buf[35], 0x01); // DefinitionSafety::Safe
-    assert_eq!(buf.len(), 36); // Total: 1 + 32 + 1 + 1 + 1 = 36 bytes
+    // buf[3..35] = comm_addr (32 bytes)
+    assert_eq!(buf[35], 0x00); // RevealConstantInfo variant: Definition
+    assert_eq!(buf[36], 0x02); // mask: bit 1 (safety)
+    assert_eq!(buf[37], 0x01); // DefinitionSafety::Safe
+    assert_eq!(buf.len(), 38); // Total: 1 + 2 + 32 + 1 + 1 + 1 = 38 bytes
   }
 
   #[test]
@@ -1957,10 +2009,10 @@ mod tests {
     let mut buf = Vec::new();
     claim.put(&mut buf);
     assert_eq!(buf[0], 0xE6);
-    assert_eq!(buf[33], 0x00); // RevealConstantInfo variant: Definition
-    assert_eq!(buf[34], 0x08); // mask: bit 3 (typ)
+    assert_eq!(buf[35], 0x00); // RevealConstantInfo variant: Definition
+    assert_eq!(buf[36], 0x08); // mask: bit 3 (typ)
     // buf[35..67] = typ address (32 bytes)
-    assert_eq!(buf.len(), 67); // Total: 1 + 32 + 1 + 1 + 32 = 67 bytes
+    assert_eq!(buf.len(), 69); // Total: 1 + 2 + 32 + 1 + 1 + 32 = 69 bytes
   }
 
   #[test]
@@ -1984,14 +2036,14 @@ mod tests {
     let mut buf = Vec::new();
     claim.put(&mut buf);
     assert_eq!(buf[0], 0xE6);
-    assert_eq!(buf[33], 0x08); // RevealConstantInfo variant: Muts
-    assert_eq!(buf[34], 0x01); // mask: bit 0 (components)
-    assert_eq!(buf[35], 0x01); // Tag0: 1 component revealed
-    assert_eq!(buf[36], 0x02); // Tag0: component index 2
-    assert_eq!(buf[37], 0x00); // RevealMutConstInfo variant: Definition
-    assert_eq!(buf[38], 0x02); // mask: bit 1 (safety)
-    assert_eq!(buf[39], 0x01); // DefinitionSafety::Safe
-    assert_eq!(buf.len(), 40); // Total: 1 + 32 + 7 = 40 bytes
+    assert_eq!(buf[35], 0x08); // RevealConstantInfo variant: Muts
+    assert_eq!(buf[36], 0x01); // mask: bit 0 (components)
+    assert_eq!(buf[37], 0x01); // Tag0: 1 component revealed
+    assert_eq!(buf[38], 0x02); // Tag0: component index 2
+    assert_eq!(buf[39], 0x00); // RevealMutConstInfo variant: Definition
+    assert_eq!(buf[40], 0x02); // mask: bit 1 (safety)
+    assert_eq!(buf[41], 0x01); // DefinitionSafety::Safe
+    assert_eq!(buf.len(), 42); // Total: 1 + 32 + 7 = 40 bytes
   }
 
   // ========== All RevealConstantInfo variant roundtrips ==========
@@ -2112,4 +2164,42 @@ mod tests {
       );
     }
   }
+  #[test]
+  fn v3_claim_fixtures_and_strict_scope() {
+    for line in
+      include_str!("../../../Tests/Fixtures/ixon-v3/claims.tsv").lines()
+    {
+      if line.starts_with('#') || line.is_empty() {
+        continue;
+      }
+      let fields: Vec<_> = line.split('\t').collect();
+      let bytes: Vec<_> = fields[2]
+        .as_bytes()
+        .as_chunks::<2>()
+        .0
+        .iter()
+        .map(|pair| {
+          u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap()
+        })
+        .collect();
+      let claim = Claim::from_bytes(&bytes).unwrap();
+      let (address, encoded) = claim.commit();
+      assert_eq!(encoded, bytes, "{}", fields[0]);
+      assert_eq!(address.hex(), fields[1]);
+      for len in 0..bytes.len() {
+        assert!(Claim::from_bytes(&bytes[..len]).is_err());
+      }
+      let mut trailing = bytes.clone();
+      trailing.push(0);
+      assert!(Claim::from_bytes(&trailing).is_err());
+      let header = if claim.proof_variant_size() + 3 >= 8 { 2 } else { 1 };
+      let mut old_format = bytes.clone();
+      old_format[header] = 2;
+      assert!(Claim::from_bytes(&old_format).is_err());
+      let mut wrong_validator = bytes.clone();
+      wrong_validator[header + 1] = 255;
+      assert!(Claim::from_bytes(&wrong_validator).is_err());
+      assert!(proof_roundtrip(&Proof::new(claim, vec![1, 2, 3])));
+    }
+  }
 }
diff --git a/crates/ixon/src/resource.rs b/crates/ixon/src/resource.rs
new file mode 100644
index 000000000..1f82de783
--- /dev/null
+++ b/crates/ixon/src/resource.rs
@@ -0,0 +1,1838 @@
+//! Resource checking for Ixon v3. Mirrors `Ix/Resource/{Basic,Check}.lean`.
+//!
+//! The address adapter supplies a globally indexed program whose erased types
+//! have been checked. External interfaces and special primitives are explicit
+//! profile assumptions. No result here certifies unverified typechecking or
+//! an unbound primitive profile.
+
+pub mod addressed;
+
+use crate::contract::{BinderContract, LetKind, Locality, ValueContract};
+use crate::expr::{Expr, Owned, Uses};
+use std::sync::Arc;
+
+pub type Term = Arc<Expr>;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Error {
+  Budget,
+  Unbound(usize),
+  BadReference(u64),
+  UnresolvedSharing(u64),
+  Unsupported(&'static str),
+  TypeMismatch,
+  BinderMismatch,
+  Usage(usize, Uses, Uses),
+  Moved(usize),
+  SharedToUnique,
+  ActiveLoan(usize),
+  Escape(usize, usize),
+  UnrestrictedEscape(usize),
+  Nonduplicable,
+  InvalidBorrow,
+  InvalidPlace,
+  InvalidScope,
+}
+
+impl Error {
+  pub const fn code(&self) -> &'static str {
+    match self {
+      Self::Budget => "budget",
+      Self::Unbound(_) => "unbound",
+      Self::BadReference(_) => "reference",
+      Self::UnresolvedSharing(_) => "sharing",
+      Self::Unsupported(_) => "unsupported",
+      Self::TypeMismatch => "type",
+      Self::BinderMismatch => "binder",
+      Self::Usage(..) => "usage",
+      Self::Moved(_) => "moved",
+      Self::SharedToUnique => "ownership",
+      Self::ActiveLoan(_) => "loan",
+      Self::Escape(..) => "escape",
+      Self::UnrestrictedEscape(_) => "unrestricted",
+      Self::Nonduplicable => "capture",
+      Self::InvalidBorrow => "borrow",
+      Self::InvalidPlace => "place",
+      Self::InvalidScope => "scope",
+    }
+  }
+}
+
+impl std::fmt::Display for Error {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(f, "resource {}: {self:?}", self.code())
+  }
+}
+impl std::error::Error for Error {}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Limits {
+  pub depth: usize,
+  pub steps: usize,
+}
+impl Default for Limits {
+  fn default() -> Self {
+    Self { depth: 256, steps: 100_000 }
+  }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DeclKind {
+  Definition,
+  Assumption,
+  Constructor,
+  TypeConstructor,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Declaration {
+  pub typ: Term,
+  pub body: Option<Term>,
+  pub kind: DeclKind,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Field {
+  pub type_ref: u64,
+  pub index: u64,
+  pub typ: Term,
+  pub contract: ValueContract,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Program {
+  pub declarations: Vec<Declaration>,
+  pub groups: Vec<Vec<usize>>,
+  /// Additional executable syntax, including addressed recursor rules.
+  pub auxiliary: Vec<(usize, Term)>,
+  pub sharing: Vec<Term>,
+  pub fields: Vec<Field>,
+  pub nat_type: Option<Term>,
+  pub string_type: Option<Term>,
+  pub shareable_types: Vec<u64>,
+  /// Profile-bound non-strict selection, with exactly three arguments.
+  pub choices: Vec<u64>,
+}
+
+#[derive(Clone, Debug)]
+struct Value {
+  typ: Term,
+  owned: Owned,
+  origins: Vec<usize>,
+  duplicable: bool,
+  place: Option<usize>,
+  loan_root: Option<usize>,
+}
+impl Value {
+  fn shared(typ: Term) -> Self {
+    Self {
+      typ,
+      owned: Owned::Shared,
+      origins: vec![],
+      duplicable: true,
+      place: None,
+      loan_root: None,
+    }
+  }
+  fn fresh(typ: Term) -> Self {
+    Self { owned: Owned::Unique, ..Self::shared(typ) }
+  }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+struct Owner {
+  live: bool,
+  unique: bool,
+  loans: Vec<usize>,
+}
+impl Owner {
+  fn move_out(&self, id: usize) -> Result<Self, Error> {
+    if !self.live {
+      return Err(Error::Moved(id));
+    }
+    if !self.unique {
+      return Err(Error::SharedToUnique);
+    }
+    if !self.loans.is_empty() {
+      return Err(Error::ActiveLoan(id));
+    }
+    Ok(Self { live: false, ..self.clone() })
+  }
+  fn share(&self, id: usize) -> Result<Self, Error> {
+    if !self.live {
+      return Err(Error::Moved(id));
+    }
+    Ok(Self { unique: false, ..self.clone() })
+  }
+  fn begin_loan(&mut self, id: usize, scope: usize) -> Result<(), Error> {
+    if !self.live {
+      return Err(Error::Moved(id));
+    }
+    self.loans.insert(0, scope);
+    Ok(())
+  }
+  fn end_loan(&mut self, scope: usize) {
+    self.loans.retain(|x| *x != scope);
+  }
+  fn join(&self, other: &Self) -> Self {
+    Self {
+      live: self.live && other.live,
+      unique: self.unique && other.unique,
+      loans: union(&self.loans, &other.loans),
+    }
+  }
+}
+
+#[derive(Clone, Debug)]
+struct Binding {
+  contract: BinderContract,
+  value: Value,
+  owner: Owner,
+  demand: Uses,
+  touched: bool,
+}
+
+#[derive(Clone, Debug)]
+struct State {
+  bindings: Vec<Binding>,
+  parents: Vec<Option<usize>>,
+  remaining: usize,
+}
+
+#[derive(Clone, Debug, Default)]
+struct Context {
+  vars: Vec<usize>,
+  scope: usize,
+}
+
+fn add(a: Uses, b: Uses) -> Uses {
+  match (a, b) {
+    (Uses::Erased, x) | (x, Uses::Erased) => x,
+    _ => Uses::Many,
+  }
+}
+fn scale(a: Uses, b: Uses) -> Uses {
+  match (a, b) {
+    (Uses::Erased, _) | (_, Uses::Erased) => Uses::Erased,
+    (Uses::Linear, x) | (x, Uses::Linear) => x,
+    (Uses::Affine, Uses::Affine) => Uses::Affine,
+    _ => Uses::Many,
+  }
+}
+fn join(a: Uses, b: Uses) -> Uses {
+  match (a, b) {
+    (Uses::Erased, Uses::Erased) => Uses::Erased,
+    (Uses::Linear, Uses::Linear) => Uses::Linear,
+    (Uses::Many, _) | (_, Uses::Many) => Uses::Many,
+    _ => Uses::Affine,
+  }
+}
+fn covers(declared: Uses, actual: Uses) -> bool {
+  match declared {
+    Uses::Many => true,
+    Uses::Affine => actual != Uses::Many,
+    Uses::Linear => actual == Uses::Linear,
+    Uses::Erased => actual == Uses::Erased,
+  }
+}
+fn union(a: &[usize], b: &[usize]) -> Vec<usize> {
+  let mut result = a.to_vec();
+  for x in b {
+    if !result.contains(x) {
+      result.push(*x);
+    }
+  }
+  result
+}
+
+struct Checker<'a> {
+  program: &'a Program,
+  state: State,
+}
+type Arrow = (BinderContract, ValueContract, Term, Term);
+type Expected = Option<(Term, ValueContract)>;
+
+impl<'a> Checker<'a> {
+  fn new(program: &'a Program, limits: Limits) -> Self {
+    Self {
+      program,
+      state: State {
+        bindings: vec![],
+        parents: vec![None],
+        remaining: limits.steps,
+      },
+    }
+  }
+  fn tick(&mut self, fuel: usize) -> Result<usize, Error> {
+    if fuel == 0 || self.state.remaining == 0 {
+      return Err(Error::Budget);
+    }
+    self.state.remaining -= 1;
+    Ok(fuel - 1)
+  }
+  fn declaration(&self, index: u64) -> Result<&Declaration, Error> {
+    let i =
+      usize::try_from(index).map_err(|_error| Error::BadReference(index))?;
+    self.program.declarations.get(i).ok_or(Error::BadReference(index))
+  }
+  fn expansion(&self, index: u64) -> Result<Term, Error> {
+    let i = usize::try_from(index)
+      .map_err(|_error| Error::UnresolvedSharing(index))?;
+    self.program.sharing.get(i).cloned().ok_or(Error::UnresolvedSharing(index))
+  }
+  fn binding(&self, id: usize) -> Result<&Binding, Error> {
+    self.state.bindings.get(id).ok_or(Error::Unbound(id))
+  }
+  fn binding_mut(&mut self, id: usize) -> Result<&mut Binding, Error> {
+    self.state.bindings.get_mut(id).ok_or(Error::Unbound(id))
+  }
+  fn push(&mut self, contract: BinderContract, value: Value) -> usize {
+    let id = self.state.bindings.len();
+    let owner =
+      Owner { live: true, unique: value.owned == Owned::Unique, loans: vec![] };
+    self.state.bindings.push(Binding {
+      contract,
+      value,
+      owner,
+      demand: Uses::Erased,
+      touched: false,
+    });
+    id
+  }
+  fn scope(&mut self, parent: usize) -> Result<usize, Error> {
+    if parent >= self.state.parents.len() {
+      return Err(Error::InvalidScope);
+    }
+    let id = self.state.parents.len();
+    self.state.parents.push(Some(parent));
+    Ok(id)
+  }
+  fn outlives(&self, origin: usize, mut destination: usize) -> bool {
+    for _ in 0..=self.state.parents.len() {
+      if origin >= self.state.parents.len()
+        || destination >= self.state.parents.len()
+      {
+        return false;
+      }
+      if origin == destination {
+        return true;
+      }
+      match self.state.parents[destination] {
+        Some(parent) => destination = parent,
+        None => return false,
+      }
+    }
+    false
+  }
+  fn check_origins(
+    &self,
+    origins: &[usize],
+    destination: usize,
+  ) -> Result<(), Error> {
+    for origin in origins {
+      if !self.outlives(*origin, destination) {
+        return Err(Error::Escape(*origin, destination));
+      }
+    }
+    Ok(())
+  }
+  fn charge(&mut self, id: usize, uses: Uses) -> Result<(), Error> {
+    let b = self.binding_mut(id)?;
+    if !b.owner.live {
+      return Err(Error::Moved(id));
+    }
+    b.demand = add(b.demand, uses);
+    b.touched = true;
+    Ok(())
+  }
+  fn validate_usage(&self, id: usize) -> Result<(), Error> {
+    let b = self.binding(id)?;
+    if !covers(b.contract.uses, b.demand) {
+      return Err(Error::Usage(id, b.contract.uses, b.demand));
+    }
+    Ok(())
+  }
+  /// Perform a place's ownership action once. Scope exit materializes its
+  /// result before ending loans, even when the result is being inferred.
+  fn materialize(&mut self, mut v: Value) -> Result<Value, Error> {
+    if let Some(id) = v.place {
+      let b = self.binding_mut(id)?;
+      b.owner = match v.owned {
+        Owned::Unique => b.owner.move_out(id)?,
+        Owned::Shared => b.owner.share(id)?,
+      };
+    }
+    v.place = None;
+    Ok(v)
+  }
+  fn consume_as(
+    &mut self,
+    required: ValueContract,
+    destination: usize,
+    mut v: Value,
+  ) -> Result<Value, Error> {
+    match required.locality {
+      Locality::Unrestricted => {
+        if let Some(origin) = v.origins.first() {
+          return Err(Error::UnrestrictedEscape(*origin));
+        }
+      },
+      Locality::Local => self.check_origins(&v.origins, destination)?,
+    }
+    if required.owned == Owned::Unique && v.owned != Owned::Unique {
+      return Err(Error::SharedToUnique);
+    }
+    if required.owned == Owned::Shared && !v.duplicable {
+      return Err(Error::Nonduplicable);
+    }
+    v.owned = required.owned;
+    v = self.materialize(v)?;
+    if required.locality == Locality::Local {
+      v.origins = union(&v.origins, &[destination]);
+    }
+    Ok(v)
+  }
+  fn invoke(&mut self, v: &Value) -> Result<(), Error> {
+    if v.owned == Owned::Shared && !v.duplicable {
+      return Err(Error::Nonduplicable);
+    }
+    if let Some(id) = v.place {
+      let b = self.binding_mut(id)?;
+      if v.owned == Owned::Unique {
+        b.owner = b.owner.move_out(id)?;
+      } else if !b.owner.live {
+        return Err(Error::Moved(id));
+      }
+    }
+    Ok(())
+  }
+  fn close_scope(&mut self, scope: usize, result: &Value) -> Result<(), Error> {
+    let parent = self
+      .state
+      .parents
+      .get(scope)
+      .copied()
+      .flatten()
+      .ok_or(Error::InvalidScope)?;
+    self.check_origins(&result.origins, parent)?;
+    for b in &mut self.state.bindings {
+      b.owner.end_loan(scope);
+    }
+    Ok(())
+  }
+  fn shift(
+    &mut self,
+    fuel: usize,
+    e: &Term,
+    amount: u64,
+    cutoff: u64,
+  ) -> Result<Term, Error> {
+    let fuel = self.tick(fuel)?;
+    Ok(match e.as_ref() {
+      Expr::Var(i) if *i >= cutoff => Expr::var(
+        i.checked_add(amount)
+          .ok_or(Error::Unsupported("variable index overflow"))?,
+      ),
+      Expr::App(f, a) => Expr::app(
+        self.shift(fuel, f, amount, cutoff)?,
+        self.shift(fuel, a, amount, cutoff)?,
+      ),
+      Expr::Lam(c, t, b) => Expr::lam_contract(
+        *c,
+        self.shift(fuel, t, amount, cutoff)?,
+        self.shift(
+          fuel,
+          b,
+          amount,
+          cutoff.checked_add(1).ok_or(Error::Budget)?,
+        )?,
+      ),
+      Expr::All(c, r, t, b) => Expr::all_contract(
+        *c,
+        *r,
+        self.shift(fuel, t, amount, cutoff)?,
+        self.shift(
+          fuel,
+          b,
+          amount,
+          cutoff.checked_add(1).ok_or(Error::Budget)?,
+        )?,
+      ),
+      Expr::Let(c, t, v, b) => Expr::let_contract(
+        *c,
+        self.shift(fuel, t, amount, cutoff)?,
+        self.shift(fuel, v, amount, cutoff)?,
+        self.shift(
+          fuel,
+          b,
+          amount,
+          cutoff.checked_add(1).ok_or(Error::Budget)?,
+        )?,
+      ),
+      Expr::Prj(t, i, v) => {
+        Expr::prj(*t, *i, self.shift(fuel, v, amount, cutoff)?)
+      },
+      Expr::Share(i) => {
+        self.shift(fuel, &self.expansion(*i)?, amount, cutoff)?
+      },
+      Expr::Rec(..) => {
+        return Err(Error::Unsupported("unresolved recursive reference"));
+      },
+      _ => e.clone(),
+    })
+  }
+  fn substitute(
+    &mut self,
+    fuel: usize,
+    e: &Term,
+    value: &Term,
+    depth: u64,
+  ) -> Result<Term, Error> {
+    let fuel = self.tick(fuel)?;
+    Ok(match e.as_ref() {
+      Expr::Var(i) if *i == depth => self.shift(fuel, value, depth, 0)?,
+      Expr::Var(i) if *i > depth => Expr::var(i - 1),
+      Expr::App(f, a) => Expr::app(
+        self.substitute(fuel, f, value, depth)?,
+        self.substitute(fuel, a, value, depth)?,
+      ),
+      Expr::Lam(c, t, b) => Expr::lam_contract(
+        *c,
+        self.substitute(fuel, t, value, depth)?,
+        self.substitute(
+          fuel,
+          b,
+          value,
+          depth.checked_add(1).ok_or(Error::Budget)?,
+        )?,
+      ),
+      Expr::All(c, r, t, b) => Expr::all_contract(
+        *c,
+        *r,
+        self.substitute(fuel, t, value, depth)?,
+        self.substitute(
+          fuel,
+          b,
+          value,
+          depth.checked_add(1).ok_or(Error::Budget)?,
+        )?,
+      ),
+      Expr::Let(c, t, v, b) => Expr::let_contract(
+        *c,
+        self.substitute(fuel, t, value, depth)?,
+        self.substitute(fuel, v, value, depth)?,
+        self.substitute(
+          fuel,
+          b,
+          value,
+          depth.checked_add(1).ok_or(Error::Budget)?,
+        )?,
+      ),
+      Expr::Prj(t, i, v) => {
+        Expr::prj(*t, *i, self.substitute(fuel, v, value, depth)?)
+      },
+      Expr::Share(i) => {
+        self.substitute(fuel, &self.expansion(*i)?, value, depth)?
+      },
+      Expr::Rec(..) => {
+        return Err(Error::Unsupported("unresolved recursive reference"));
+      },
+      _ => e.clone(),
+    })
+  }
+  fn whnf(&mut self, fuel: usize, e: &Term) -> Result<Term, Error> {
+    let fuel = self.tick(fuel)?;
+    match e.as_ref() {
+      Expr::Share(i) => self.whnf(fuel, &self.expansion(*i)?),
+      Expr::Let(_, _, v, b) => {
+        let body = self.substitute(fuel, b, v, 0)?;
+        self.whnf(fuel, &body)
+      },
+      Expr::App(f, a) => {
+        let f = self.whnf(fuel, f)?;
+        if let Expr::Lam(_, _, b) = f.as_ref() {
+          let b = self.substitute(fuel, b, a, 0)?;
+          self.whnf(fuel, &b)
+        } else {
+          Ok(Expr::app(f, a.clone()))
+        }
+      },
+      Expr::Ref(i, _) => match self.declaration(*i)?.body.clone() {
+        Some(body) => self.whnf(fuel, &body),
+        None => Ok(e.clone()),
+      },
+      Expr::Rec(..) => {
+        Err(Error::Unsupported("unresolved recursive reference"))
+      },
+      _ => Ok(e.clone()),
+    }
+  }
+  fn compatible(
+    &mut self,
+    fuel: usize,
+    a: &Term,
+    b: &Term,
+  ) -> Result<bool, Error> {
+    let fuel = self.tick(fuel)?;
+    if a == b {
+      return Ok(true);
+    }
+    let a = self.whnf(fuel, a)?;
+    let b = self.whnf(fuel, b)?;
+    Ok(match (a.as_ref(), b.as_ref()) {
+      (Expr::All(c, r, t, b), Expr::All(d, s, u, e)) => {
+        c == d
+          && r == s
+          && self.compatible(fuel, t, u)?
+          && self.compatible(fuel, b, e)?
+      },
+      (Expr::Lam(c, t, b), Expr::Lam(d, u, e)) => {
+        c == d && self.compatible(fuel, t, u)? && self.compatible(fuel, b, e)?
+      },
+      (Expr::App(f, a), Expr::App(g, b)) => {
+        self.compatible(fuel, f, g)? && self.compatible(fuel, a, b)?
+      },
+      (Expr::Prj(t, i, v), Expr::Prj(u, j, w)) => {
+        t == u && i == j && self.compatible(fuel, v, w)?
+      },
+      (Expr::Sort(_), Expr::Sort(_)) => true,
+      (Expr::Ref(i, _), Expr::Ref(j, _)) => i == j,
+      _ => a == b,
+    })
+  }
+  fn require_type(
+    &mut self,
+    fuel: usize,
+    actual: &Term,
+    expected: &Term,
+  ) -> Result<(), Error> {
+    if self.compatible(fuel, actual, expected)? {
+      Ok(())
+    } else {
+      Err(Error::TypeMismatch)
+    }
+  }
+  fn arrow(&mut self, fuel: usize, typ: &Term) -> Result<Arrow, Error> {
+    let t = self.whnf(fuel, typ)?;
+    match t.as_ref() {
+      Expr::All(c, r, t, b) => Ok((*c, *r, t.clone(), b.clone())),
+      _ => Err(Error::Unsupported(
+        "a callable interface must expose its arrow contracts",
+      )),
+    }
+  }
+  fn is_shareable(&mut self, fuel: usize, typ: &Term) -> Result<bool, Error> {
+    let typ = self.whnf(fuel, typ)?;
+    Ok(match typ.as_ref() {
+      Expr::Ref(i, _) => self.program.shareable_types.contains(i),
+      Expr::Sort(_) => true,
+      _ => false,
+    })
+  }
+  fn literal_type(typ: &Option<Term>) -> Result<Term, Error> {
+    typ.clone().ok_or(Error::Unsupported(
+      "literal type is absent from the addressed profile",
+    ))
+  }
+  fn read_variable(
+    &mut self,
+    fuel: usize,
+    ctx: &Context,
+    index: u64,
+    uses: Uses,
+  ) -> Result<Value, Error> {
+    let n = usize::try_from(index).map_err(|_error| Error::Budget)?;
+    let pos = ctx
+      .vars
+      .len()
+      .checked_sub(n)
+      .and_then(|v| v.checked_sub(1))
+      .ok_or(Error::Unbound(n))?;
+    let id = ctx.vars[pos];
+    let b = self.binding(id)?.clone();
+    self.charge(id, uses)?;
+    if let Some(root) = b.value.loan_root
+      && !self.binding(root)?.owner.live
+    {
+      return Err(Error::Moved(root));
+    }
+    let typ = self.shift(
+      fuel,
+      &b.value.typ,
+      index.checked_add(1).ok_or(Error::Budget)?,
+      0,
+    )?;
+    Ok(Value {
+      typ,
+      place: Some(id),
+      owned: if b.owner.unique { Owned::Unique } else { Owned::Shared },
+      ..b.value
+    })
+  }
+  fn field(&self, type_ref: u64, index: u64) -> Result<Field, Error> {
+    self
+      .program
+      .fields
+      .iter()
+      .find(|f| f.type_ref == type_ref && f.index == index)
+      .cloned()
+      .ok_or(Error::Unsupported("projection has no checked field rule"))
+  }
+  fn place(
+    &mut self,
+    fuel: usize,
+    ctx: &Context,
+    e: &Term,
+  ) -> Result<Value, Error> {
+    let fuel = self.tick(fuel)?;
+    match e.as_ref() {
+      Expr::Var(i) => {
+        let value = self.read_variable(fuel, ctx, *i, Uses::Erased)?;
+        let id = value.place.ok_or(Error::InvalidPlace)?;
+        if self.binding(id)?.contract.uses == Uses::Erased {
+          return Err(Error::Unsupported(
+            "an erased binding cannot be borrowed",
+          ));
+        }
+        Ok(value)
+      },
+      Expr::Share(i) => self.place(fuel, ctx, &self.expansion(*i)?),
+      Expr::Prj(t, i, v) => {
+        let mut v = self.place(fuel, ctx, v)?;
+        let f = self.field(*t, *i)?;
+        v.duplicable = f.contract.owned == Owned::Shared
+          || self.is_shareable(fuel, &f.typ)?;
+        v.typ = f.typ;
+        if v.owned != Owned::Unique || f.contract.owned != Owned::Unique {
+          v.owned = Owned::Shared;
+        }
+        Ok(v)
+      },
+      _ => Err(Error::InvalidPlace),
+    }
+  }
+  fn type_of(
+    &mut self,
+    fuel: usize,
+    ctx: &Context,
+    e: &Term,
+  ) -> Result<Term, Error> {
+    let fuel = self.tick(fuel)?;
+    match e.as_ref() {
+      Expr::Var(i) => {
+        let n = usize::try_from(*i).map_err(|_error| Error::Budget)?;
+        let pos = ctx
+          .vars
+          .len()
+          .checked_sub(n)
+          .and_then(|v| v.checked_sub(1))
+          .ok_or(Error::Unbound(n))?;
+        let typ = self.binding(ctx.vars[pos])?.value.typ.clone();
+        self.shift(fuel, &typ, i.checked_add(1).ok_or(Error::Budget)?, 0)
+      },
+      Expr::Ref(i, _) => Ok(self.declaration(*i)?.typ.clone()),
+      Expr::Share(i) => self.type_of(fuel, ctx, &self.expansion(*i)?),
+      Expr::Rec(..) => {
+        Err(Error::Unsupported("unresolved recursive reference"))
+      },
+      Expr::Sort(_) | Expr::All(..) => Ok(Expr::sort(0)),
+      Expr::Nat(_) => Self::literal_type(&self.program.nat_type),
+      Expr::Str(_) => Self::literal_type(&self.program.string_type),
+      Expr::Prj(t, i, _) => Ok(self.field(*t, *i)?.typ),
+      Expr::App(f, a) => {
+        let t = self.type_of(fuel, ctx, f)?;
+        let (_, _, _, b) = self.arrow(fuel, &t)?;
+        self.substitute(fuel, &b, a, 0)
+      },
+      Expr::Lam(c, t, b) => {
+        let before = self.state.bindings.clone();
+        let id = self.push(*c, Value::shared(t.clone()));
+        let mut inner = ctx.clone();
+        inner.vars.push(id);
+        let codomain = self.type_of(fuel, &inner, b)?;
+        self.state.bindings = before;
+        Ok(Expr::all_contract(*c, ValueContract::shared(), t.clone(), codomain))
+      },
+      Expr::Let(c, t, v, b) => {
+        let before = self.state.bindings.clone();
+        let id = self.push(c.binder, Value::shared(t.clone()));
+        let mut inner = ctx.clone();
+        inner.vars.push(id);
+        let typ = self.type_of(fuel, &inner, b)?;
+        self.state.bindings = before;
+        self.substitute(fuel, &typ, v, 0)
+      },
+    }
+  }
+  fn finish(
+    &mut self,
+    fuel: usize,
+    destination: usize,
+    expected: Expected,
+    value: Value,
+  ) -> Result<Value, Error> {
+    match expected {
+      None => Ok(value),
+      Some((typ, contract)) => {
+        self.require_type(fuel, &value.typ, &typ)?;
+        self.consume_as(contract, destination, value)
+      },
+    }
+  }
+  fn ordinary_call(
+    &mut self,
+    fuel: usize,
+    ctx: &Context,
+    f: &Term,
+    a: &Term,
+    destination: usize,
+    grade: Uses,
+  ) -> Result<Value, Error> {
+    let fn_type = self.type_of(fuel, ctx, f)?;
+    let (input, result, domain, codomain) = self.arrow(fuel, &fn_type)?;
+    let scope =
+      if result.locality == Locality::Local { destination } else { ctx.scope };
+    let f = self.analyze(fuel, ctx, f, None, scope, grade)?;
+    self.require_type(fuel, &f.typ, &fn_type)?;
+    self.invoke(&f)?;
+    let arg = self.analyze(
+      fuel,
+      ctx,
+      a,
+      Some((domain, input.value)),
+      scope,
+      scale(grade, input.uses),
+    )?;
+    let typ = self.substitute(fuel, &codomain, a, 0)?;
+    let origins = if result.locality == Locality::Local {
+      union(&union(&f.origins, &arg.origins), &[scope])
+    } else {
+      vec![]
+    };
+    let duplicable =
+      result.owned == Owned::Shared || self.is_shareable(fuel, &typ)?;
+    Ok(Value { owned: result.owned, origins, duplicable, ..Value::shared(typ) })
+  }
+  fn selection(
+    &mut self,
+    fuel: usize,
+    ctx: &Context,
+    index: u64,
+    args: &[Term],
+    destination: usize,
+    grade: Uses,
+  ) -> Result<Value, Error> {
+    let typ = self.declaration(index)?.typ.clone();
+    let (c, _, selector_type, tail) = self.arrow(fuel, &typ)?;
+    self.analyze(
+      fuel,
+      ctx,
+      &args[0],
+      Some((selector_type, c.value)),
+      ctx.scope,
+      scale(grade, c.uses),
+    )?;
+    let tail = self.substitute(fuel, &tail, &args[0], 0)?;
+    let (_, _, left_type, tail) = self.arrow(fuel, &tail)?;
+    let tail = self.substitute(fuel, &tail, &args[1], 0)?;
+    let (_, result, right_type, output_type) = self.arrow(fuel, &tail)?;
+    let output_type = self.substitute(fuel, &output_type, &args[2], 0)?;
+    self.require_type(fuel, &left_type, &right_type)?;
+    self.require_type(fuel, &left_type, &output_type)?;
+    let before = self.state.bindings.clone();
+    let left = self.analyze(
+      fuel,
+      ctx,
+      &args[1],
+      Some((left_type, result)),
+      destination,
+      grade,
+    )?;
+    let left_bindings = self.state.bindings.clone();
+    self.state.bindings = before.clone();
+    let right = self.analyze(
+      fuel,
+      ctx,
+      &args[2],
+      Some((right_type, result)),
+      destination,
+      grade,
+    )?;
+    let mut bindings = vec![];
+    for (i, mut b) in left_bindings.into_iter().take(before.len()).enumerate() {
+      let r = self.binding(i)?;
+      b.owner = b.owner.join(&r.owner);
+      b.demand = join(b.demand, r.demand);
+      b.touched |= r.touched;
+      bindings.push(b);
+    }
+    self.state.bindings = bindings;
+    Ok(Value {
+      typ: output_type,
+      owned: if left.owned == Owned::Unique && right.owned == Owned::Unique {
+        Owned::Unique
+      } else {
+        Owned::Shared
+      },
+      origins: union(&left.origins, &right.origins),
+      duplicable: left.duplicable && right.duplicable,
+      place: if left.place == right.place { left.place } else { None },
+      loan_root: if left.loan_root == right.loan_root {
+        left.loan_root
+      } else {
+        None
+      },
+    })
+  }
+  fn analyze(
+    &mut self,
+    fuel: usize,
+    ctx: &Context,
+    e: &Term,
+    expected: Expected,
+    destination: usize,
+    grade: Uses,
+  ) -> Result<Value, Error> {
+    let fuel = self.tick(fuel)?;
+    if grade == Uses::Erased {
+      let typ = self.type_of(fuel, ctx, e)?;
+      if let Some((expected_type, _)) = expected {
+        self.require_type(fuel, &typ, &expected_type)?;
+      }
+      return Ok(Value::fresh(typ));
+    }
+    if let Some((t, _)) = &expected
+      && matches!(self.whnf(fuel, t)?.as_ref(), Expr::Sort(_))
+    {
+      return Ok(Value::fresh(t.clone()));
+    }
+    if grade != Uses::Linear {
+      let before = self.state.bindings.clone();
+      for b in &mut self.state.bindings {
+        b.demand = Uses::Erased;
+        b.touched = false;
+      }
+      let output =
+        self.analyze(fuel, ctx, e, expected, destination, Uses::Linear)?;
+      for (id, old) in before.into_iter().enumerate() {
+        let used = self.binding_mut(id)?;
+        used.demand = add(old.demand, scale(grade, used.demand));
+        used.touched |= old.touched;
+      }
+      return Ok(output);
+    }
+    let value = match e.as_ref() {
+      Expr::Share(i) => self.analyze(
+        fuel,
+        ctx,
+        &self.expansion(*i)?,
+        expected.clone(),
+        destination,
+        grade,
+      )?,
+      Expr::Var(i) => self.read_variable(fuel, ctx, *i, grade)?,
+      Expr::Ref(i, _) => {
+        if self.program.choices.contains(i) {
+          return Err(Error::Unsupported(
+            "selection primitives cannot escape as function values",
+          ));
+        }
+        Value::shared(self.declaration(*i)?.typ.clone())
+      },
+      Expr::Rec(..) => {
+        return Err(Error::Unsupported("unresolved recursive reference"));
+      },
+      Expr::Sort(_) | Expr::All(..) => Value::fresh(Expr::sort(0)),
+      Expr::Nat(_) => Value::fresh(Self::literal_type(&self.program.nat_type)?),
+      Expr::Str(_) => {
+        Value::fresh(Self::literal_type(&self.program.string_type)?)
+      },
+      Expr::Lam(input, domain, body) => {
+        let (result, codomain) = match &expected {
+          Some((t, _)) => {
+            let (declared, r, t, b) = self.arrow(fuel, t)?;
+            if *input != declared {
+              return Err(Error::BinderMismatch);
+            }
+            self.require_type(fuel, domain, &t)?;
+            (r, Some(b))
+          },
+          None => (ValueContract::shared(), None),
+        };
+        let before = self.state.bindings.clone();
+        for b in &mut self.state.bindings {
+          b.demand = Uses::Erased;
+          b.touched = false;
+        }
+        let caller_scope = self.scope(ctx.scope)?;
+        let body_scope = self.scope(caller_scope)?;
+        let duplicable = input.value.owned == Owned::Shared
+          || self.is_shareable(fuel, domain)?;
+        let parameter = self.push(
+          *input,
+          Value {
+            owned: input.value.owned,
+            duplicable,
+            origins: if input.value.locality == Locality::Local {
+              vec![caller_scope]
+            } else {
+              vec![]
+            },
+            ..Value::shared(domain.clone())
+          },
+        );
+        let mut inner = ctx.clone();
+        inner.vars.push(parameter);
+        inner.scope = body_scope;
+        let body_expected = codomain.as_ref().map(|t| (t.clone(), result));
+        let output = self.analyze(
+          fuel,
+          &inner,
+          body,
+          body_expected.clone(),
+          caller_scope,
+          Uses::Linear,
+        )?;
+        let output = if body_expected.is_some() {
+          output
+        } else {
+          self.consume_as(result, caller_scope, output)?
+        };
+        self.validate_usage(parameter)?;
+        let mut origins = vec![];
+        let mut duplicable = true;
+        let mut bindings = vec![];
+        for (id, old) in before.into_iter().enumerate() {
+          let used = self.binding(id)?;
+          let mut owner = used.owner.clone();
+          let mut demand = used.demand;
+          if used.touched {
+            origins = union(&origins, &old.value.origins);
+            if old.contract.uses != Uses::Many || !old.value.duplicable {
+              duplicable = false;
+            }
+            if old.owner.unique {
+              old.owner.move_out(id)?;
+              owner.live = false;
+              if demand == Uses::Erased {
+                demand = Uses::Linear;
+              }
+              duplicable = false;
+            }
+          }
+          let demand = add(old.demand, scale(grade, demand));
+          let touched = old.touched || used.touched;
+          bindings.push(Binding { owner, demand, touched, ..old });
+        }
+        self.state.bindings = bindings;
+        Value {
+          origins,
+          duplicable,
+          ..Value::fresh(Expr::all_contract(
+            *input,
+            result,
+            domain.clone(),
+            codomain.unwrap_or(output.typ),
+          ))
+        }
+      },
+      Expr::Let(contract, typ, initializer, body) => {
+        let scope = self.scope(ctx.scope)?;
+        let initialized = match contract.kind {
+          LetKind::Value => self.analyze(
+            fuel,
+            ctx,
+            initializer,
+            Some((typ.clone(), contract.binder.value)),
+            if contract.binder.value.locality == Locality::Local {
+              scope
+            } else {
+              destination
+            },
+            scale(grade, contract.binder.uses),
+          )?,
+          LetKind::BorrowShared => {
+            if contract.binder.value != ValueContract::local_shared() {
+              return Err(Error::InvalidBorrow);
+            }
+            let mut v = self.place(fuel, ctx, initializer)?;
+            self.require_type(fuel, &v.typ, typ)?;
+            if !self.is_shareable(fuel, typ)? && !v.duplicable {
+              return Err(Error::Nonduplicable);
+            }
+            let owner_place = v.place.ok_or(Error::InvalidPlace)?;
+            let root = v.loan_root.unwrap_or(owner_place);
+            let b = self.binding_mut(root)?;
+            b.owner.begin_loan(root, scope)?;
+            v.owned = Owned::Shared;
+            v.duplicable = true;
+            v.origins = union(&v.origins, &[scope]);
+            v.place = None;
+            v.loan_root = Some(root);
+            v
+          },
+        };
+        let id =
+          self.push(contract.binder, Value { typ: typ.clone(), ..initialized });
+        let mut inner = ctx.clone();
+        inner.vars.push(id);
+        inner.scope = scope;
+        let body_expected = match &expected {
+          None => None,
+          Some((t, c)) => Some((self.shift(fuel, t, 1, 0)?, *c)),
+        };
+        let output = self.analyze(
+          fuel,
+          &inner,
+          body,
+          body_expected,
+          destination,
+          grade,
+        )?;
+        self.validate_usage(id)?;
+        let mut output = self.materialize(output)?;
+        self.close_scope(scope, &output)?;
+        output.typ = self.substitute(fuel, &output.typ, initializer, 0)?;
+        output
+      },
+      Expr::Prj(t, i, value) => {
+        let mut v = self.analyze(fuel, ctx, value, None, destination, grade)?;
+        let field = self.field(*t, *i)?;
+        v.duplicable = field.contract.owned == Owned::Shared
+          || self.is_shareable(fuel, &field.typ)?;
+        v.typ = field.typ;
+        if v.owned != Owned::Unique || field.contract.owned != Owned::Unique {
+          v.owned = Owned::Shared;
+        }
+        v
+      },
+      Expr::App(f, a) => {
+        let mut head = e.clone();
+        let mut args = vec![];
+        let mut split_fuel = fuel;
+        loop {
+          split_fuel = self.tick(split_fuel)?;
+          match head.as_ref() {
+            Expr::App(f, a) => {
+              args.push(a.clone());
+              head = f.clone();
+            },
+            Expr::Share(index) => head = self.expansion(*index)?,
+            _ => break,
+          }
+        }
+        args.reverse();
+        if let Expr::Ref(i, _) = head.as_ref() {
+          if self.program.choices.contains(i) {
+            if args.len() != 3 {
+              return Err(Error::Unsupported(
+                "selection primitives require a complete application",
+              ));
+            }
+            self.selection(fuel, ctx, *i, &args, destination, grade)?
+          } else {
+            self.ordinary_call(fuel, ctx, f, a, destination, grade)?
+          }
+        } else {
+          self.ordinary_call(fuel, ctx, f, a, destination, grade)?
+        }
+      },
+    };
+    self.finish(fuel, destination, expected, value)
+  }
+}
+
+pub fn check_definition(
+  program: &Program,
+  index: usize,
+  limits: Limits,
+) -> Result<(), Error> {
+  let declaration =
+    program.declarations.get(index).ok_or(Error::BadReference(index as u64))?;
+  let body = declaration
+    .body
+    .as_ref()
+    .ok_or(Error::Unsupported("definition has no body"))?;
+  let mut checker = Checker::new(program, limits);
+  let scope = checker.scope(0)?;
+  checker.analyze(
+    limits.depth,
+    &Context { scope, vars: vec![] },
+    body,
+    Some((declaration.typ.clone(), ValueContract::shared())),
+    scope,
+    Uses::Linear,
+  )?;
+  Ok(())
+}
+
+#[derive(Clone, Debug, Default)]
+struct Scan {
+  annotated: bool,
+  dependencies: Vec<usize>,
+}
+impl Scan {
+  fn merge(mut self, other: Self) -> Self {
+    self.annotated |= other.annotated;
+    self.dependencies.extend(other.dependencies);
+    self
+  }
+}
+
+impl Checker<'_> {
+  fn scan(&mut self, fuel: usize, e: &Term) -> Result<Scan, Error> {
+    if fuel == 0 {
+      return Err(Error::Budget);
+    }
+    let mut finished = std::collections::HashSet::new();
+    let mut active = std::collections::HashSet::new();
+    let mut stack = vec![(e.clone(), false)];
+    let mut scan = Scan::default();
+    while let Some((e, closing)) = stack.pop() {
+      let key = e.clone();
+      if closing {
+        active.remove(&key);
+        finished.insert(key);
+        continue;
+      }
+      if active.contains(&key) {
+        return Err(Error::Unsupported("cyclic sharing"));
+      }
+      if finished.contains(&key) {
+        continue;
+      }
+      self.tick(1)?;
+      active.insert(key);
+      stack.push((e.clone(), true));
+      match e.as_ref() {
+        Expr::Ref(i, _) => {
+          self.declaration(*i)?;
+          scan.dependencies.push(
+            usize::try_from(*i).map_err(|_error| Error::BadReference(*i))?,
+          );
+        },
+        Expr::Rec(..) => {
+          return Err(Error::Unsupported("unresolved recursive reference"));
+        },
+        Expr::Share(i) => stack.push((self.expansion(*i)?, false)),
+        Expr::Prj(i, _, v) => {
+          self.declaration(*i)?;
+          scan.dependencies.push(
+            usize::try_from(*i).map_err(|_error| Error::BadReference(*i))?,
+          );
+          stack.push((v.clone(), false));
+        },
+        Expr::App(f, a) => {
+          stack.push((a.clone(), false));
+          stack.push((f.clone(), false));
+        },
+        Expr::Lam(c, t, b) => {
+          scan.annotated |= *c != BinderContract::default();
+          stack.push((b.clone(), false));
+          stack.push((t.clone(), false));
+        },
+        Expr::All(c, r, t, b) => {
+          scan.annotated |=
+            *c != BinderContract::default() || *r != ValueContract::shared();
+          stack.push((b.clone(), false));
+          stack.push((t.clone(), false));
+        },
+        Expr::Let(c, t, v, b) => {
+          scan.annotated |=
+            c.binder != BinderContract::default() || c.kind != LetKind::Value;
+          stack.push((b.clone(), false));
+          stack.push((v.clone(), false));
+          stack.push((t.clone(), false));
+        },
+        _ => {},
+      }
+    }
+    Ok(scan)
+  }
+  fn check_constructor_type(
+    &mut self,
+    fuel: usize,
+    typ: &Term,
+    has_finite: bool,
+    has_local: bool,
+  ) -> Result<(), Error> {
+    let fuel = self.tick(fuel)?;
+    let typ = self.whnf(fuel, typ)?;
+    if let Expr::All(input, result, domain, codomain) = typ.as_ref() {
+      let domain = self.whnf(fuel, domain)?;
+      let erased =
+        input.uses == Uses::Erased || matches!(domain.as_ref(), Expr::Sort(_));
+      if !covers(input.uses, if erased { Uses::Erased } else { Uses::Linear }) {
+        return Err(Error::Unsupported(
+          "constructor input quantity does not cover its stored occurrence",
+        ));
+      }
+      let finite = has_finite
+        || (!erased
+          && (input.uses != Uses::Many || input.value.owned == Owned::Unique));
+      let local_capture =
+        has_local || (!erased && input.value.locality == Locality::Local);
+      if finite && result.owned != Owned::Unique {
+        return Err(Error::Unsupported(
+          "constructor result drops a finite or unique capture",
+        ));
+      }
+      if local_capture && result.locality != Locality::Local {
+        return Err(Error::Unsupported(
+          "constructor result drops a local capture",
+        ));
+      }
+      self.check_constructor_type(fuel, codomain, finite, local_capture)?;
+    }
+    Ok(())
+  }
+}
+
+/// Dependencies propagate resource relevance to callers and to every member
+/// of a mutually addressed block. Only wholly ordinary components bypass the
+/// resource analysis; erased typechecking is still required for them.
+pub fn relevance(
+  program: &Program,
+  limits: Limits,
+) -> Result<Vec<bool>, Error> {
+  let size = program.declarations.len();
+  let mut reverse = vec![vec![]; size];
+  let mut marked = vec![false; size];
+  let mut queue = vec![];
+  for (i, d) in program.declarations.iter().enumerate() {
+    let mut checker = Checker::new(program, limits);
+    let scan = checker.scan(limits.depth, &d.typ)?;
+    let scan = match &d.body {
+      None => scan,
+      Some(body) => scan.merge(checker.scan(limits.depth, body)?),
+    };
+    if scan.annotated {
+      marked[i] = true;
+      queue.push(i);
+    }
+    for dependency in scan.dependencies {
+      reverse
+        .get_mut(dependency)
+        .ok_or(Error::BadReference(dependency as u64))?
+        .push(i);
+    }
+  }
+  for (i, expression) in &program.auxiliary {
+    if *i >= size {
+      return Err(Error::BadReference(*i as u64));
+    }
+    let mut checker = Checker::new(program, limits);
+    let scan = checker.scan(limits.depth, expression)?;
+    if scan.annotated && !marked[*i] {
+      marked[*i] = true;
+      queue.push(*i);
+    }
+    for dependency in scan.dependencies {
+      reverse
+        .get_mut(dependency)
+        .ok_or(Error::BadReference(dependency as u64))?
+        .push(*i);
+    }
+  }
+  for f in &program.fields {
+    let i = usize::try_from(f.type_ref)
+      .map_err(|_error| Error::BadReference(f.type_ref))?;
+    let m = marked.get_mut(i).ok_or(Error::BadReference(f.type_ref))?;
+    if f.contract != ValueContract::shared() && !*m {
+      *m = true;
+      queue.push(i);
+    }
+  }
+  for group in &program.groups {
+    if let Some(first) = group.first().copied() {
+      if first >= size {
+        return Err(Error::BadReference(first as u64));
+      }
+      for member in group {
+        if *member >= size {
+          return Err(Error::BadReference(*member as u64));
+        }
+        reverse[first].push(*member);
+        reverse[*member].push(first);
+      }
+    }
+  }
+  let mut cursor = 0;
+  while cursor < queue.len() {
+    let i = queue[cursor];
+    cursor += 1;
+    for dependent in &reverse[i] {
+      if !marked[*dependent] {
+        marked[*dependent] = true;
+        queue.push(*dependent);
+      }
+    }
+  }
+  Ok(marked)
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct Policy {
+  pub assumptions: Vec<usize>,
+  pub shareable_types: Vec<usize>,
+  pub choices: Vec<usize>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct AdmissionError {
+  pub declaration: Option<usize>,
+  pub error: Error,
+}
+
+pub fn admit_program(
+  program: &Program,
+  policy: &Policy,
+  limits: Limits,
+) -> Result<(), AdmissionError> {
+  for index in &program.choices {
+    let index = usize::try_from(*index).map_err(|_error| AdmissionError {
+      declaration: None,
+      error: Error::BadReference(*index),
+    })?;
+    if !policy.choices.contains(&index) || !policy.assumptions.contains(&index)
+    {
+      return Err(AdmissionError {
+        declaration: Some(index),
+        error: Error::Unsupported(
+          "selection behavior is absent from the bound profile",
+        ),
+      });
+    }
+    let d = program.declarations.get(index).ok_or(AdmissionError {
+      declaration: None,
+      error: Error::BadReference(index as u64),
+    })?;
+    if d.kind != DeclKind::Assumption {
+      return Err(AdmissionError {
+        declaration: Some(index),
+        error: Error::Unsupported(
+          "selection behavior requires an external primitive interface",
+        ),
+      });
+    }
+  }
+  for index in &program.shareable_types {
+    let index = usize::try_from(*index).map_err(|_error| AdmissionError {
+      declaration: None,
+      error: Error::BadReference(*index),
+    })?;
+    if !policy.shareable_types.contains(&index) {
+      return Err(AdmissionError {
+        declaration: Some(index),
+        error: Error::Unsupported(
+          "shareable representation is absent from the bound profile",
+        ),
+      });
+    }
+  }
+  let marked = relevance(program, limits)
+    .map_err(|error| AdmissionError { declaration: None, error })?;
+  for (i, d) in program.declarations.iter().enumerate() {
+    if marked[i] {
+      let result = match d.kind {
+        DeclKind::Definition => check_definition(program, i, limits),
+        DeclKind::Assumption => {
+          if policy.assumptions.contains(&i) {
+            Ok(())
+          } else {
+            Err(Error::Unsupported(
+              "external resource interface is absent from the bound profile",
+            ))
+          }
+        },
+        DeclKind::Constructor => Checker::new(program, limits)
+          .check_constructor_type(limits.depth, &d.typ, false, false),
+        DeclKind::TypeConstructor => Ok(()),
+      };
+      result.map_err(|error| AdmissionError { declaration: Some(i), error })?;
+    }
+  }
+  Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  fn b(uses: Uses, value: ValueContract) -> BinderContract {
+    BinderContract { uses, value }
+  }
+  fn nat() -> Term {
+    Expr::reference(0, vec![])
+  }
+  fn arr(
+    input: BinderContract,
+    result: ValueContract,
+    domain: Term,
+    codomain: Term,
+  ) -> Term {
+    Expr::all_contract(input, result, domain, codomain)
+  }
+  fn unary(input: BinderContract, result: ValueContract) -> Term {
+    arr(input, result, nat(), nat())
+  }
+  fn choice(result: ValueContract) -> Term {
+    arr(
+      b(Uses::Linear, ValueContract::shared()),
+      ValueContract::shared(),
+      nat(),
+      arr(
+        b(Uses::Affine, result),
+        ValueContract::shared(),
+        nat(),
+        unary(b(Uses::Affine, result), result),
+      ),
+    )
+  }
+  fn assumption(typ: Term) -> Declaration {
+    Declaration { typ, body: None, kind: DeclKind::Assumption }
+  }
+  fn identity(input: BinderContract, result: ValueContract) -> Declaration {
+    Declaration {
+      typ: unary(input, result),
+      body: Some(Expr::lam_contract(input, nat(), Expr::var(0))),
+      kind: DeclKind::Definition,
+    }
+  }
+  fn program() -> Program {
+    let mut p = Program {
+      declarations: vec![
+        Declaration {
+          typ: Expr::sort(0),
+          body: None,
+          kind: DeclKind::TypeConstructor,
+        },
+        assumption(unary(
+          b(Uses::Many, ValueContract::local_shared()),
+          ValueContract::shared(),
+        )),
+        identity(
+          b(Uses::Linear, ValueContract::local_shared()),
+          ValueContract::local_shared(),
+        ),
+        identity(
+          b(Uses::Linear, ValueContract::unique()),
+          ValueContract::unique(),
+        ),
+        assumption(unary(
+          b(Uses::Erased, ValueContract::shared()),
+          ValueContract::shared(),
+        )),
+        assumption(unary(
+          b(Uses::Many, ValueContract::shared()),
+          ValueContract::shared(),
+        )),
+        assumption(choice(ValueContract::shared())),
+        Declaration {
+          typ: Expr::sort(0),
+          body: None,
+          kind: DeclKind::TypeConstructor,
+        },
+        assumption(arr(
+          b(Uses::Linear, ValueContract::local_shared()),
+          ValueContract::local_shared(),
+          nat(),
+          Expr::reference(7, vec![]),
+        )),
+        assumption(choice(ValueContract::local_shared())),
+        assumption(choice(ValueContract::unique())),
+      ],
+      ..Default::default()
+    };
+    p.fields.push(Field {
+      type_ref: 7,
+      index: 0,
+      typ: nat(),
+      contract: ValueContract::unique(),
+    });
+    p.fields.push(Field {
+      type_ref: 7,
+      index: 1,
+      typ: unary(
+        b(Uses::Many, ValueContract::shared()),
+        ValueContract::shared(),
+      ),
+      contract: ValueContract::unique(),
+    });
+    p.fields.push(Field {
+      type_ref: 7,
+      index: 2,
+      typ: unary(
+        b(Uses::Many, ValueContract::shared()),
+        ValueContract::shared(),
+      ),
+      contract: ValueContract::shared(),
+    });
+    p.nat_type = Some(nat());
+    p.string_type = Some(nat());
+    p.sharing.push(Expr::var(0));
+    p.sharing.push(Expr::reference(6, vec![]));
+    p.shareable_types = vec![0, 7];
+    p.choices = vec![6, 9, 10];
+    p
+  }
+  fn parse(hex: &str) -> Term {
+    let bytes: Vec<_> = hex
+      .as_bytes()
+      .as_chunks::<2>()
+      .0
+      .iter()
+      .map(|pair| {
+        u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap()
+      })
+      .collect();
+    assert_eq!(bytes.len() * 2, hex.len());
+    let mut input = bytes.as_slice();
+    let expr = crate::serialize::get_expr(&mut input).unwrap();
+    assert!(input.is_empty());
+    expr
+  }
+
+  #[test]
+  fn shared_resource_acceptance_and_rejection_fixtures() {
+    let mut count = 0;
+    for line in include_str!("../../../Tests/Fixtures/ixon-v3/resource.tsv")
+      .lines()
+      .filter(|l| !l.starts_with('#') && !l.is_empty())
+    {
+      let cols: Vec<_> = line.split('\t').collect();
+      assert_eq!(cols.len(), 4);
+      let mut p = program();
+      let index = p.declarations.len();
+      p.declarations.push(Declaration {
+        typ: parse(cols[2]),
+        body: Some(parse(cols[3])),
+        kind: DeclKind::Definition,
+      });
+      let actual = check_definition(&p, index, Limits::default());
+      let code = actual.as_ref().map_or_else(|e| e.code(), |()| "ok");
+      assert_eq!(code, cols[1], "{}: {actual:?}", cols[0]);
+      count += 1;
+    }
+    assert!(count >= 55);
+  }
+
+  #[test]
+  fn every_input_result_contract_is_checked() {
+    for input in 0..16 {
+      let input = BinderContract::from_bits(input).unwrap();
+      for result in 0..4 {
+        let result = ValueContract::from_bits(result).unwrap();
+        let mut p = program();
+        let index = p.declarations.len();
+        let body =
+          if input.uses == Uses::Erased { Expr::nat(0) } else { Expr::var(0) };
+        p.declarations.push(Declaration {
+          typ: unary(input, result),
+          body: Some(Expr::lam_contract(input, nat(), body)),
+          kind: DeclKind::Definition,
+        });
+        let allowed = input.uses == Uses::Erased
+          || ((input.value.owned == Owned::Unique
+            || result.owned == Owned::Shared)
+            && (input.value.locality == Locality::Unrestricted
+              || result.locality == Locality::Local));
+        assert_eq!(
+          check_definition(&p, index, Limits::default()).is_ok(),
+          allowed,
+          "{input:?} -> {result:?}"
+        );
+      }
+    }
+  }
+
+  #[test]
+  fn scope_exit_never_restores_moved_or_shared_owners() {
+    for live in [false, true] {
+      for unique in [false, true] {
+        for loans in [vec![], vec![1], vec![1, 2]] {
+          let owner = Owner { live, unique, loans };
+          let mut ended = owner.clone();
+          ended.end_loan(1);
+          assert_eq!((ended.live, ended.unique), (live, unique));
+          assert_eq!(
+            owner.move_out(0).is_ok(),
+            live && unique && owner.loans.is_empty()
+          );
+          if let Ok(shared) = owner.share(0) {
+            assert!(!shared.unique);
+          }
+          for other_live in [false, true] {
+            for other_unique in [false, true] {
+              let other =
+                Owner { live: other_live, unique: other_unique, loans: vec![] };
+              let joined = owner.join(&other);
+              assert_eq!(joined.live, live && other_live);
+              assert_eq!(joined.unique, unique && other_unique);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  #[test]
+  fn cyclic_sharing_exhausts_the_bound() {
+    let mut p = program();
+    p.sharing = vec![Arc::new(Expr::Share(0))];
+    let mut c = Checker::new(&p, Limits::default());
+    assert_eq!(
+      c.analyze(
+        20,
+        &Context::default(),
+        &Arc::new(Expr::Share(0)),
+        None,
+        0,
+        Uses::Linear
+      )
+      .unwrap_err(),
+      Error::Budget
+    );
+  }
+
+  #[test]
+  fn literals_require_an_addressed_type() {
+    let mut p = program();
+    p.nat_type = None;
+    let mut c = Checker::new(&p, Limits::default());
+    assert!(matches!(
+      c.analyze(20, &Context::default(), &Expr::nat(0), None, 0, Uses::Linear),
+      Err(Error::Unsupported(_))
+    ));
+  }
+
+  fn policy() -> Policy {
+    Policy {
+      assumptions: vec![1, 4, 6, 8, 9, 10],
+      shareable_types: vec![0, 7],
+      choices: vec![6, 9, 10],
+    }
+  }
+
+  #[test]
+  fn admission_binds_external_contracts_behavior_and_representations() {
+    let p = program();
+    assert!(admit_program(&p, &policy(), Limits::default()).is_ok());
+    let mut missing = policy();
+    missing.assumptions = vec![6, 9, 10];
+    assert!(admit_program(&p, &missing, Limits::default()).is_err());
+    let mut missing = policy();
+    missing.choices.clear();
+    assert!(admit_program(&p, &missing, Limits::default()).is_err());
+    let mut missing = policy();
+    missing.shareable_types.clear();
+    assert!(admit_program(&p, &missing, Limits::default()).is_err());
+  }
+
+  #[test]
+  fn relevance_scans_shared_dags_and_rejects_cycles() {
+    let mut sharing = vec![Expr::sort(0)];
+    for i in 0..40 {
+      sharing.push(Expr::app(Expr::share(i), Expr::share(i)));
+    }
+    let mut p = Program {
+      declarations: vec![Declaration {
+        typ: Expr::sort(0),
+        body: Some(Expr::share(40)),
+        kind: DeclKind::Definition,
+      }],
+      sharing,
+      ..Default::default()
+    };
+    assert_eq!(
+      relevance(&p, Limits { depth: 1, steps: 200 }).unwrap(),
+      vec![false]
+    );
+    p.sharing = vec![Expr::share(0)];
+    p.declarations[0].body = Some(Expr::share(0));
+    assert!(relevance(&p, Limits::default()).is_err());
+  }
+
+  #[test]
+  fn relevance_reaches_aliases_and_mutual_siblings() {
+    let mut p = program();
+    let typ =
+      unary(b(Uses::Many, ValueContract::shared()), ValueContract::shared());
+    p.declarations.push(Declaration {
+      typ: typ.clone(),
+      body: Some(Expr::reference(2, vec![])),
+      kind: DeclKind::Definition,
+    });
+    p.declarations.push(Declaration {
+      typ,
+      body: Some(Expr::reference(11, vec![])),
+      kind: DeclKind::Definition,
+    });
+    let marked = relevance(&p, Limits::default()).unwrap();
+    assert!(marked[11] && marked[12]);
+    let rejected = admit_program(&p, &policy(), Limits::default()).unwrap_err();
+    assert_eq!(rejected.declaration, Some(11));
+    assert_eq!(rejected.error, Error::TypeMismatch);
+    let mut p = program();
+    p.declarations.push(Declaration {
+      typ: nat(),
+      body: Some(Expr::nat(0)),
+      kind: DeclKind::Definition,
+    });
+    p.groups.push(vec![2, 11]);
+    assert!(relevance(&p, Limits::default()).unwrap()[11]);
+    assert!(admit_program(&p, &policy(), Limits::default()).is_ok());
+  }
+
+  #[test]
+  fn constructors_keep_captures_in_all_results() {
+    let linear = b(Uses::Linear, ValueContract::shared());
+    let many = b(Uses::Many, ValueContract::shared());
+    let local = b(Uses::Many, ValueContract::local_shared());
+    for (typ, allowed) in [
+      (unary(linear, ValueContract::shared()), false),
+      (unary(linear, ValueContract::unique()), true),
+      (unary(local, ValueContract::shared()), false),
+      (unary(local, ValueContract::local_shared()), true),
+      (
+        arr(
+          linear,
+          ValueContract::unique(),
+          nat(),
+          unary(many, ValueContract::shared()),
+        ),
+        false,
+      ),
+      (
+        arr(
+          linear,
+          ValueContract::unique(),
+          nat(),
+          unary(many, ValueContract::unique()),
+        ),
+        true,
+      ),
+      (
+        arr(
+          b(Uses::Erased, ValueContract::shared()),
+          ValueContract::shared(),
+          Expr::sort(0),
+          nat(),
+        ),
+        true,
+      ),
+      (arr(linear, ValueContract::unique(), Expr::sort(0), nat()), false),
+    ] {
+      let mut p = program();
+      p.declarations.push(Declaration {
+        typ,
+        body: None,
+        kind: DeclKind::Constructor,
+      });
+      assert_eq!(
+        admit_program(&p, &policy(), Limits::default()).is_ok(),
+        allowed
+      );
+    }
+  }
+}
diff --git a/crates/ixon/src/resource/addressed.rs b/crates/ixon/src/resource/addressed.rs
new file mode 100644
index 000000000..75ec7a548
--- /dev/null
+++ b/crates/ixon/src/resource/addressed.rs
@@ -0,0 +1,1029 @@
+//! Addressed resource interfaces. Mirrors `Ix/Resource/Addressed.lean`.
+//! Resource admission and erased typing are separate prerequisites; `prepare`
+//! resolves bytes and interfaces but deliberately creates no certificate.
+
+use super::*;
+use crate::constant::{
+  Constant, ConstantInfo, Definition, MutConst, Recursor, ctor_proj_constant,
+  defn_proj_constant, indc_proj_constant, recr_proj_constant,
+};
+use crate::env::Env;
+use crate::tag::Tag0;
+use ix_common::address::Address;
+use ix_common::env::DefinitionSafety;
+use rustc_hash::FxHashMap;
+
+pub const VALIDATOR_ID: &str = "ixon-v3/resource-v1";
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct Profile {
+  pub assumptions: Vec<Address>,
+  pub shareable_types: Vec<Address>,
+  pub choices: Vec<Address>,
+  pub nat_type: Option<Address>,
+  pub string_type: Option<Address>,
+  pub limits: Limits,
+}
+
+impl Profile {
+  pub fn validate(&self) -> Result<(), String> {
+    for list in [&self.assumptions, &self.shareable_types, &self.choices] {
+      if list.windows(2).any(|pair| pair[0] >= pair[1]) {
+        return Err(
+          "resource profile: address lists must be strictly increasing".into(),
+        );
+      }
+    }
+    if self.choices.iter().any(|c| !self.assumptions.contains(c)) {
+      return Err(
+        "resource profile: selection primitive must be an explicit assumption"
+          .into(),
+      );
+    }
+    if self.limits.depth == 0 || self.limits.steps == 0 {
+      return Err("resource profile: invalid checker limits".into());
+    }
+    Ok(())
+  }
+
+  pub fn bytes(&self) -> Vec<u8> {
+    let mut bytes = format!("{VALIDATOR_ID}/profile\0").into_bytes();
+    for list in [&self.assumptions, &self.shareable_types, &self.choices] {
+      Tag0::new(list.len() as u64).put(&mut bytes);
+      for address in list {
+        bytes.extend_from_slice(address.as_bytes());
+      }
+    }
+    for address in [&self.nat_type, &self.string_type] {
+      match address {
+        None => bytes.push(0),
+        Some(address) => {
+          bytes.push(1);
+          bytes.extend_from_slice(address.as_bytes());
+        },
+      }
+    }
+    Tag0::new(self.limits.depth as u64).put(&mut bytes);
+    Tag0::new(self.limits.steps as u64).put(&mut bytes);
+    bytes
+  }
+
+  pub fn address(&self) -> Result<Address, String> {
+    self.validate()?;
+    Ok(Address::hash(&self.bytes()))
+  }
+
+  pub fn from_bytes(mut bytes: &[u8]) -> Result<Self, String> {
+    let prefix = format!("{VALIDATOR_ID}/profile\0");
+    bytes = bytes
+      .strip_prefix(prefix.as_bytes())
+      .ok_or("resource profile: wrong validator identifier")?;
+    fn list(bytes: &mut &[u8]) -> Result<Vec<Address>, String> {
+      let count = Tag0::get(bytes)?.size;
+      if count > (bytes.len() / 32) as u64 {
+        return Err("resource profile: impossible address count".into());
+      }
+      let mut result = vec![];
+      for _ in 0..count {
+        let (head, tail) = bytes.split_at(32);
+        result.push(
+          Address::from_slice(head)
+            .map_err(|_error| "resource profile: invalid address")?,
+        );
+        *bytes = tail;
+      }
+      Ok(result)
+    }
+    fn optional(bytes: &mut &[u8]) -> Result<Option<Address>, String> {
+      match crate::serialize::get_u8(bytes)? {
+        0 => Ok(None),
+        1 => {
+          let (head, tail) = bytes
+            .split_at_checked(32)
+            .ok_or("resource profile: truncated address")?;
+          *bytes = tail;
+          Ok(Some(
+            Address::from_slice(head)
+              .map_err(|_error| "resource profile: invalid address")?,
+          ))
+        },
+        _ => Err("resource profile: invalid optional address tag".into()),
+      }
+    }
+    let profile = Self {
+      assumptions: list(&mut bytes)?,
+      shareable_types: list(&mut bytes)?,
+      choices: list(&mut bytes)?,
+      nat_type: optional(&mut bytes)?,
+      string_type: optional(&mut bytes)?,
+      limits: Limits {
+        depth: usize::try_from(Tag0::get(&mut bytes)?.size)
+          .map_err(|_error| "resource profile: depth overflow")?,
+        steps: usize::try_from(Tag0::get(&mut bytes)?.size)
+          .map_err(|_error| "resource profile: steps overflow")?,
+      },
+    };
+    if !bytes.is_empty() {
+      return Err("resource profile: trailing bytes".into());
+    }
+    profile.validate()?;
+    Ok(profile)
+  }
+}
+
+#[derive(Clone, Debug)]
+pub struct AddressedProgram {
+  pub program: Program,
+  pub policy: Policy,
+  pub addresses: Vec<Address>,
+  pub profile_address: Address,
+}
+
+struct Pending {
+  address: Address,
+  parent: Address,
+  constant: Arc<Constant>,
+  members: Vec<Address>,
+  declaration: Declaration,
+  auxiliary: Vec<Term>,
+}
+
+fn definition(d: &Definition) -> Declaration {
+  Declaration {
+    typ: d.typ.clone(),
+    body: Some(d.value.clone()),
+    kind: if d.safety == DefinitionSafety::Safe {
+      DeclKind::Definition
+    } else {
+      DeclKind::Assumption
+    },
+  }
+}
+
+fn recursor(d: &Recursor) -> Declaration {
+  Declaration { typ: d.typ.clone(), body: None, kind: DeclKind::Assumption }
+}
+
+fn member_wrapper(block: &Address, index: u64, member: &MutConst) -> Constant {
+  match member {
+    MutConst::Defn(_) => defn_proj_constant(index, block.clone()),
+    MutConst::Indc(_) => indc_proj_constant(index, block.clone()),
+    MutConst::Recr(_) => recr_proj_constant(index, block.clone()),
+  }
+}
+
+fn require_wrapper(
+  constants: &FxHashMap<Address, Arc<Constant>>,
+  expected: &Constant,
+) -> Result<Address, String> {
+  let address = expected.commit().0;
+  match constants.get(&address) {
+    Some(actual) if actual.as_ref() == expected => Ok(address),
+    _ => Err(format!(
+      "resource adapter: missing or invalid canonical projection {address:?}"
+    )),
+  }
+}
+
+fn index(
+  indices: &FxHashMap<Address, u64>,
+  address: &Address,
+) -> Result<u64, String> {
+  indices.get(address).copied().ok_or_else(|| {
+    format!("resource adapter: missing typed interface {address:?}")
+  })
+}
+
+fn native_index(index: u64) -> Result<usize, String> {
+  usize::try_from(index)
+    .map_err(|_error| "resource adapter: index overflow".into())
+}
+
+struct Tables<'a> {
+  refs: &'a [Address],
+  members: &'a [Address],
+  indices: &'a FxHashMap<Address, u64>,
+  kinds: &'a [DeclKind],
+  blobs: &'a FxHashMap<Address, u64>,
+  univ_count: usize,
+  share_count: usize,
+  share_offset: usize,
+}
+
+impl Tables<'_> {
+  fn reference(&self, i: u64) -> Result<&Address, String> {
+    let i = usize::try_from(i)
+      .map_err(|_error| "resource adapter: reference index overflow")?;
+    self
+      .refs
+      .get(i)
+      .ok_or_else(|| "resource adapter: reference index out of bounds".into())
+  }
+
+  fn universes(&self, levels: &[u64]) -> Result<(), String> {
+    if levels.iter().any(|l| *l >= self.univ_count as u64) {
+      return Err("resource adapter: universe index out of bounds".into());
+    }
+    Ok(())
+  }
+
+  fn remap(&self, fuel: usize, e: &Term) -> Result<Term, String> {
+    let fuel = fuel
+      .checked_sub(1)
+      .ok_or("resource adapter: expression depth exceeded")?;
+    Ok(Arc::new(match e.as_ref() {
+      Expr::Var(_) => return Ok(e.clone()),
+      Expr::Sort(level) => {
+        self.universes(&[*level])?;
+        return Ok(e.clone());
+      },
+      Expr::Ref(i, levels) => {
+        self.universes(levels)?;
+        Expr::Ref(index(self.indices, self.reference(*i)?)?, levels.clone())
+      },
+      Expr::Rec(i, levels) => {
+        self.universes(levels)?;
+        let i = usize::try_from(*i)
+          .map_err(|_error| "resource adapter: recursive index overflow")?;
+        let address = self
+          .members
+          .get(i)
+          .ok_or("resource adapter: recursive index out of bounds")?;
+        Expr::Ref(index(self.indices, address)?, levels.clone())
+      },
+      Expr::Nat(i) | Expr::Str(i) => {
+        let address = self.reference(*i)?;
+        let id = *self.blobs.get(address).ok_or_else(|| {
+          format!("resource adapter: missing literal blob {address:?}")
+        })?;
+        match e.as_ref() {
+          Expr::Nat(_) => Expr::Nat(id),
+          _ => Expr::Str(id),
+        }
+      },
+      Expr::Share(i) => {
+        let i = usize::try_from(*i)
+          .map_err(|_error| "resource adapter: sharing index overflow")?;
+        if i >= self.share_count {
+          return Err("resource adapter: sharing index out of bounds".into());
+        }
+        Expr::Share(
+          self
+            .share_offset
+            .checked_add(i)
+            .and_then(|n| u64::try_from(n).ok())
+            .ok_or("resource adapter: index overflow")?,
+        )
+      },
+      Expr::Prj(i, field, value) => {
+        let id = index(self.indices, self.reference(*i)?)?;
+        if self.kinds.get(native_index(id)?) != Some(&DeclKind::TypeConstructor)
+        {
+          return Err(
+            "resource adapter: projection owner is not an inductive type"
+              .into(),
+          );
+        }
+        Expr::Prj(id, *field, self.remap(fuel, value)?)
+      },
+      Expr::App(f, a) => Expr::App(self.remap(fuel, f)?, self.remap(fuel, a)?),
+      Expr::Lam(c, t, b) => {
+        Expr::Lam(*c, self.remap(fuel, t)?, self.remap(fuel, b)?)
+      },
+      Expr::All(c, r, t, b) => {
+        Expr::All(*c, *r, self.remap(fuel, t)?, self.remap(fuel, b)?)
+      },
+      Expr::Let(c, t, v, b) => Expr::Let(
+        *c,
+        self.remap(fuel, t)?,
+        self.remap(fuel, v)?,
+        self.remap(fuel, b)?,
+      ),
+    }))
+  }
+}
+
+fn closed(
+  checker: &mut Checker<'_>,
+  fuel: usize,
+  depth: u64,
+  e: &Term,
+) -> Result<bool, Error> {
+  let fuel = checker.tick(fuel)?;
+  Ok(match e.as_ref() {
+    Expr::Var(i) => *i < depth,
+    Expr::Share(i) => closed(checker, fuel, depth, &checker.expansion(*i)?)?,
+    Expr::Rec(..) => false,
+    Expr::App(f, a) => {
+      closed(checker, fuel, depth, f)? && closed(checker, fuel, depth, a)?
+    },
+    Expr::Lam(_, t, b) | Expr::All(_, _, t, b) => {
+      closed(checker, fuel, depth, t)? && closed(checker, fuel, depth + 1, b)?
+    },
+    Expr::Let(_, t, v, b) => {
+      closed(checker, fuel, depth, t)?
+        && closed(checker, fuel, depth, v)?
+        && closed(checker, fuel, depth + 1, b)?
+    },
+    Expr::Prj(_, _, v) => closed(checker, fuel, depth, v)?,
+    _ => true,
+  })
+}
+
+fn fields(
+  program: &Program,
+  limits: Limits,
+  type_ref: u64,
+  ctor: u64,
+  count: u64,
+) -> Result<Vec<Field>, Error> {
+  let mut checker = Checker::new(program, limits);
+  let mut typ = checker.declaration(ctor)?.typ.clone();
+  let mut fields = vec![];
+  for index in 0..count {
+    typ = checker.whnf(limits.depth, &typ)?;
+    let Expr::All(input, _, domain, body) = typ.as_ref() else {
+      return Err(Error::Unsupported("constructor field telescope"));
+    };
+    if input.uses != Uses::Many
+      || !closed(&mut checker, limits.depth, 0, domain)?
+    {
+      return Err(Error::Unsupported(
+        "dependent or finite-use projection field",
+      ));
+    }
+    fields.push(Field {
+      type_ref,
+      index,
+      typ: domain.clone(),
+      contract: input.value,
+    });
+    typ = body.clone();
+  }
+  Ok(fields)
+}
+
+pub fn prepare(
+  env: &Env,
+  profile: &Profile,
+) -> Result<AddressedProgram, String> {
+  let profile_address = profile.address()?;
+  let mut entries: Vec<_> =
+    env.consts.iter().map(|r| (r.key().clone(), r.value().clone())).collect();
+  entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+  let mut constants = FxHashMap::default();
+  for (address, lazy) in &entries {
+    let raw = lazy.raw_bytes();
+    if Address::hash(raw) != *address {
+      return Err(format!(
+        "resource adapter: constant hash mismatch {address:?}"
+      ));
+    }
+    let mut input = raw;
+    let constant = Constant::get(&mut input)?;
+    let mut canonical = vec![];
+    constant.put(&mut canonical);
+    if !input.is_empty() || canonical != raw {
+      return Err(format!(
+        "resource adapter: noncanonical constant {address:?}"
+      ));
+    }
+    constants.insert(address.clone(), Arc::new(constant));
+  }
+  let mut pending = vec![];
+  let mut groups = vec![];
+  let mut field_specs = vec![];
+  for (address, _) in &entries {
+    let constant = &constants[address];
+    let parent = address.clone();
+    let mut push = |address: Address,
+                    members: Vec<Address>,
+                    declaration: Declaration,
+                    auxiliary: Vec<Term>| {
+      pending.push(Pending {
+        address,
+        parent: parent.clone(),
+        constant: constant.clone(),
+        members,
+        declaration,
+        auxiliary,
+      });
+    };
+    match &constant.info {
+      ConstantInfo::Defn(d) => {
+        push(address.clone(), vec![address.clone()], definition(d), vec![])
+      },
+      ConstantInfo::Recr(r) => push(
+        address.clone(),
+        vec![address.clone()],
+        recursor(r),
+        r.rules.iter().map(|r| r.rhs.clone()).collect(),
+      ),
+      ConstantInfo::Axio(a) => push(
+        address.clone(),
+        vec![],
+        Declaration {
+          typ: a.typ.clone(),
+          body: None,
+          kind: DeclKind::Assumption,
+        },
+        vec![],
+      ),
+      ConstantInfo::Quot(q) => push(
+        address.clone(),
+        vec![],
+        Declaration {
+          typ: q.typ.clone(),
+          body: None,
+          kind: DeclKind::Assumption,
+        },
+        vec![],
+      ),
+      ConstantInfo::Muts(members) => {
+        if members.is_empty() {
+          return Err("resource adapter: empty mutual block".into());
+        }
+        let addresses = members
+          .iter()
+          .enumerate()
+          .map(|(i, m)| {
+            require_wrapper(&constants, &member_wrapper(address, i as u64, m))
+          })
+          .collect::<Result<Vec<_>, _>>()?;
+        let mut group = addresses.clone();
+        for (i, member) in members.iter().enumerate() {
+          let addr = &addresses[i];
+          match member {
+            MutConst::Defn(d) => {
+              push(addr.clone(), addresses.clone(), definition(d), vec![])
+            },
+            MutConst::Recr(r) => push(
+              addr.clone(),
+              addresses.clone(),
+              recursor(r),
+              r.rules.iter().map(|r| r.rhs.clone()).collect(),
+            ),
+            MutConst::Indc(ind) => {
+              push(
+                addr.clone(),
+                addresses.clone(),
+                Declaration {
+                  typ: ind.typ.clone(),
+                  body: None,
+                  kind: if ind.is_unsafe {
+                    DeclKind::Assumption
+                  } else {
+                    DeclKind::TypeConstructor
+                  },
+                },
+                vec![],
+              );
+              for (j, ctor) in ind.ctors.iter().enumerate() {
+                let ctor_addr = require_wrapper(
+                  &constants,
+                  &ctor_proj_constant(i as u64, j as u64, address.clone()),
+                )?;
+                if ctor.cidx != j as u64
+                  || ctor.params != ind.params
+                  || ctor.lvls != ind.lvls
+                {
+                  return Err(
+                    "resource adapter: inconsistent constructor header".into(),
+                  );
+                }
+                push(
+                  ctor_addr.clone(),
+                  addresses.clone(),
+                  Declaration {
+                    typ: ctor.typ.clone(),
+                    body: None,
+                    kind: if ctor.is_unsafe {
+                      DeclKind::Assumption
+                    } else {
+                      DeclKind::Constructor
+                    },
+                  },
+                  vec![],
+                );
+                group.push(ctor_addr.clone());
+                if !ind.is_unsafe
+                  && !ctor.is_unsafe
+                  && ind.params == 0
+                  && ind.indices == 0
+                  && ind.ctors.len() == 1
+                {
+                  field_specs.push((addr.clone(), ctor_addr, ctor.fields));
+                }
+              }
+            },
+          }
+        }
+        groups.push(group);
+      },
+      _ => {},
+    }
+  }
+  pending.sort_unstable_by(|a, b| a.address.cmp(&b.address));
+  let mut indices = FxHashMap::default();
+  let mut addresses = vec![];
+  for (i, p) in pending.iter().enumerate() {
+    if indices.insert(p.address.clone(), i as u64).is_some() {
+      return Err("resource adapter: duplicate resolved declaration".into());
+    }
+    addresses.push(p.address.clone());
+  }
+  for (address, constant) in &constants {
+    if matches!(
+      constant.info,
+      ConstantInfo::DPrj(_)
+        | ConstantInfo::IPrj(_)
+        | ConstantInfo::RPrj(_)
+        | ConstantInfo::CPrj(_)
+    ) && !indices.contains_key(address)
+    {
+      return Err(format!(
+        "resource adapter: invalid or orphan projection {address:?}"
+      ));
+    }
+  }
+  let mut blob_entries: Vec<_> =
+    env.blobs.iter().map(|r| (r.key().clone(), r.value().clone())).collect();
+  blob_entries.sort_unstable_by(|a, b| a.0.cmp(&b.0));
+  let mut blobs = FxHashMap::default();
+  for (address, bytes) in blob_entries {
+    if Address::hash(&bytes) != address {
+      return Err(format!("resource adapter: blob hash mismatch {address:?}"));
+    }
+    blobs.insert(address, blobs.len() as u64);
+  }
+  let kinds: Vec<_> = pending.iter().map(|p| p.declaration.kind).collect();
+  let mut program = Program::default();
+  let mut offsets = FxHashMap::default();
+  for p in &pending {
+    let tables = Tables {
+      refs: &p.constant.refs,
+      members: &p.members,
+      indices: &indices,
+      kinds: &kinds,
+      blobs: &blobs,
+      univ_count: p.constant.univs.len(),
+      share_count: p.constant.sharing.len(),
+      share_offset: offsets
+        .get(&p.parent)
+        .copied()
+        .unwrap_or(program.sharing.len()),
+    };
+    if offsets.insert(p.parent.clone(), tables.share_offset).is_none() {
+      for e in &p.constant.sharing {
+        program.sharing.push(tables.remap(profile.limits.depth, e)?);
+      }
+    }
+    let i = program.declarations.len();
+    program.declarations.push(Declaration {
+      typ: tables.remap(profile.limits.depth, &p.declaration.typ)?,
+      body: p
+        .declaration
+        .body
+        .as_ref()
+        .map(|e| tables.remap(profile.limits.depth, e))
+        .transpose()?,
+      kind: p.declaration.kind,
+    });
+    for e in &p.auxiliary {
+      program.auxiliary.push((i, tables.remap(profile.limits.depth, e)?));
+    }
+  }
+  program.groups = groups
+    .iter()
+    .map(|g| {
+      g.iter().map(|a| index(&indices, a).and_then(native_index)).collect()
+    })
+    .collect::<Result<_, _>>()?;
+  let resolve = |list: &[Address]| {
+    list.iter().map(|a| index(&indices, a)).collect::<Result<Vec<_>, String>>()
+  };
+  let assumptions = resolve(&profile.assumptions)?;
+  let shareable = resolve(&profile.shareable_types)?;
+  let choices = resolve(&profile.choices)?;
+  let literal_type = |a: &Address| -> Result<Term, String> {
+    let i = index(&indices, a)?;
+    if kinds.get(native_index(i)?) != Some(&DeclKind::TypeConstructor) {
+      return Err(
+        "resource adapter: literal type must be a checked nominal type".into(),
+      );
+    }
+    Ok(Expr::reference(i, vec![]))
+  };
+  program.nat_type = profile.nat_type.as_ref().map(literal_type).transpose()?;
+  program.string_type =
+    profile.string_type.as_ref().map(literal_type).transpose()?;
+  program.shareable_types = shareable.clone();
+  program.choices = choices.clone();
+  for (typ, ctor, count) in field_specs {
+    if let Ok(derived) = fields(
+      &program,
+      profile.limits,
+      index(&indices, &typ)?,
+      index(&indices, &ctor)?,
+      count,
+    ) {
+      program.fields.extend(derived);
+    }
+  }
+  Ok(AddressedProgram {
+    program,
+    addresses,
+    profile_address,
+    policy: Policy {
+      assumptions: assumptions
+        .into_iter()
+        .map(native_index)
+        .collect::<Result<_, _>>()?,
+      shareable_types: shareable
+        .into_iter()
+        .map(native_index)
+        .collect::<Result<_, _>>()?,
+      choices: choices
+        .into_iter()
+        .map(native_index)
+        .collect::<Result<_, _>>()?,
+    },
+  })
+}
+
+/// Resource-only admission; the combined validator also checks erased typing.
+pub fn check_resources(
+  env: &Env,
+  profile: &Profile,
+) -> Result<AddressedProgram, String> {
+  let resolved = prepare(env, profile)?;
+  admit_program(&resolved.program, &resolved.policy, profile.limits).map_err(
+    |error| {
+      format!(
+        "resource admission {:?}: {:?}",
+        error.declaration.and_then(|i| resolved.addresses.get(i)),
+        error.error
+      )
+    },
+  )?;
+  Ok(resolved)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::constant::{Axiom, Constructor, DefKind, Inductive, RecursorRule};
+  use crate::univ::Univ;
+
+  fn store(env: &Env, c: Constant) -> Address {
+    let addr = c.commit().0;
+    env.store_const(addr.clone(), c);
+    addr
+  }
+  fn unit_block() -> Constant {
+    Constant::with_tables(
+      ConstantInfo::Muts(vec![MutConst::Indc(Inductive {
+        is_unsafe: false,
+        lvls: 0,
+        params: 0,
+        indices: 0,
+        typ: Expr::sort(0),
+        ctors: vec![Constructor {
+          is_unsafe: false,
+          lvls: 0,
+          cidx: 0,
+          params: 0,
+          fields: 0,
+          typ: Expr::rec(0, vec![]),
+        }],
+      })]),
+      vec![],
+      vec![],
+      vec![Univ::zero()],
+    )
+  }
+  fn unit_env() -> (Env, Address) {
+    let env = Env::new();
+    let block = store(&env, unit_block());
+    let typ = store(&env, indc_proj_constant(0, block.clone()));
+    store(&env, ctor_proj_constant(0, 0, block));
+    (env, typ)
+  }
+  fn linear_local() -> BinderContract {
+    BinderContract { uses: Uses::Linear, value: ValueContract::local_shared() }
+  }
+  fn identity(
+    unit: &Address,
+    input: BinderContract,
+    result: ValueContract,
+  ) -> Constant {
+    Constant::with_tables(
+      ConstantInfo::Defn(Definition {
+        kind: DefKind::Definition,
+        safety: DefinitionSafety::Safe,
+        lvls: 0,
+        typ: Expr::all_contract(
+          input,
+          result,
+          Expr::reference(0, vec![]),
+          Expr::reference(0, vec![]),
+        ),
+        value: Expr::lam_contract(
+          input,
+          Expr::reference(0, vec![]),
+          Expr::share(0),
+        ),
+      }),
+      vec![Expr::var(0)],
+      vec![unit.clone()],
+      vec![],
+    )
+  }
+  fn profile(unit: &Address) -> Profile {
+    Profile {
+      nat_type: Some(unit.clone()),
+      shareable_types: vec![unit.clone()],
+      ..Default::default()
+    }
+  }
+
+  #[test]
+  fn interfaces_profiles_and_integrity() {
+    let (env, unit) = unit_env();
+    let p = profile(&unit);
+    let id_const =
+      identity(&unit, linear_local(), ValueContract::local_shared());
+    let id = store(&env, id_const.clone());
+    let prepared = check_resources(&env, &p).unwrap();
+    assert_eq!(prepared.program.declarations.len(), 3);
+    assert_eq!(prepared.program.groups.len(), 1);
+    assert!(
+      prepare(&env, &Profile { nat_type: Some(id.clone()), ..p.clone() })
+        .is_err()
+    );
+    assert!(
+      Profile {
+        shareable_types: vec![unit.clone(), unit.clone()],
+        ..p.clone()
+      }
+      .address()
+      .is_err()
+    );
+    assert!(
+      Profile { choices: vec![id.clone()], ..p.clone() }.address().is_err()
+    );
+    let (bad_escape, _) = unit_env();
+    store(
+      &bad_escape,
+      identity(&unit, linear_local(), ValueContract::shared()),
+    );
+    assert!(check_resources(&bad_escape, &p).is_err());
+    let missing = Env::new();
+    store(&missing, id_const.clone());
+    assert!(prepare(&missing, &p).is_err());
+    let bad_hash = env.clone();
+    bad_hash.store_const(Address::hash(&[9]), id_const.clone());
+    assert!(prepare(&bad_hash, &p).is_err());
+    let (trailing, _) = unit_env();
+    let mut raw = id_const.commit().1;
+    raw.push(0);
+    trailing.store_const_lazy(Address::hash(&raw), raw.into());
+    assert!(prepare(&trailing, &p).is_err());
+    let (orphan, _) = unit_env();
+    store(&orphan, indc_proj_constant(99, unit_block().commit().0));
+    assert!(prepare(&orphan, &p).is_err());
+    let (missing_ctor, _) = unit_env();
+    missing_ctor
+      .consts
+      .remove(&ctor_proj_constant(0, 0, unit_block().commit().0).commit().0);
+    assert!(prepare(&missing_ctor, &p).is_err());
+    let (extra_tables, _) = unit_env();
+    let mut wrapper = indc_proj_constant(0, unit_block().commit().0);
+    wrapper.univs.push(Univ::zero());
+    store(&extra_tables, wrapper);
+    assert!(prepare(&extra_tables, &p).is_err());
+  }
+
+  #[test]
+  fn explicit_assumptions_and_rule_dependencies() {
+    let (env, unit) = unit_env();
+    let mut p = profile(&unit);
+    let external = Constant::with_tables(
+      ConstantInfo::Axio(Axiom {
+        is_unsafe: false,
+        lvls: 0,
+        typ: Expr::all_contract(
+          linear_local(),
+          ValueContract::shared(),
+          Expr::reference(0, vec![]),
+          Expr::reference(0, vec![]),
+        ),
+      }),
+      vec![],
+      vec![unit.clone()],
+      vec![],
+    );
+    let external = store(&env, external);
+    assert!(check_resources(&env, &p).is_err());
+    p.assumptions.push(external);
+    check_resources(&env, &p).unwrap();
+    let (rec_env, _) = unit_env();
+    let rec = Constant::with_tables(
+      ConstantInfo::Recr(Recursor {
+        k: false,
+        is_unsafe: false,
+        lvls: 0,
+        params: 0,
+        indices: 0,
+        motives: 0,
+        minors: 0,
+        typ: Expr::reference(0, vec![]),
+        rules: vec![RecursorRule {
+          fields: 0,
+          rhs: Expr::lam_contract(
+            linear_local(),
+            Expr::reference(0, vec![]),
+            Expr::var(0),
+          ),
+        }],
+      }),
+      vec![],
+      vec![unit.clone()],
+      vec![],
+    );
+    let rec = store(&rec_env, rec);
+    assert!(check_resources(&rec_env, &profile(&unit)).is_err());
+    check_resources(
+      &rec_env,
+      &Profile { assumptions: vec![rec], ..profile(&unit) },
+    )
+    .unwrap();
+  }
+
+  #[test]
+  fn global_blob_identities_and_integrity() {
+    let (env, unit) = unit_env();
+    for byte in [0, 1] {
+      let blob = env.store_blob(vec![byte]);
+      store(
+        &env,
+        Constant::with_tables(
+          ConstantInfo::Defn(Definition {
+            kind: DefKind::Definition,
+            safety: DefinitionSafety::Safe,
+            lvls: 0,
+            typ: Expr::reference(0, vec![]),
+            value: Expr::nat(1),
+          }),
+          vec![],
+          vec![unit.clone(), blob],
+          vec![],
+        ),
+      );
+    }
+    let resolved = prepare(&env, &profile(&unit)).unwrap();
+    let bodies: Vec<_> = resolved
+      .program
+      .declarations
+      .iter()
+      .filter_map(|d| d.body.as_ref())
+      .collect();
+    assert_eq!(bodies.len(), 2);
+    assert_ne!(bodies[0], bodies[1]);
+    env.blobs.insert(Address::hash(&[9]), vec![0]);
+    assert!(prepare(&env, &profile(&unit)).is_err());
+  }
+
+  #[test]
+  fn mutual_recursive_interfaces() {
+    let (env, unit) = unit_env();
+    let input =
+      BinderContract { uses: Uses::Linear, value: ValueContract::unique() };
+    let typ = Expr::all_contract(
+      input,
+      ValueContract::unique(),
+      Expr::reference(0, vec![]),
+      Expr::reference(0, vec![]),
+    );
+    let members = [1, 0]
+      .map(|i| {
+        MutConst::Defn(Definition {
+          kind: DefKind::Definition,
+          safety: DefinitionSafety::Safe,
+          lvls: 0,
+          typ: typ.clone(),
+          value: Expr::lam_contract(
+            input,
+            Expr::reference(0, vec![]),
+            Expr::app(Expr::rec(i, vec![]), Expr::var(0)),
+          ),
+        })
+      })
+      .to_vec();
+    let block = store(
+      &env,
+      Constant::with_tables(
+        ConstantInfo::Muts(members),
+        vec![],
+        vec![unit.clone()],
+        vec![],
+      ),
+    );
+    store(&env, defn_proj_constant(0, block.clone()));
+    store(&env, defn_proj_constant(1, block));
+    let resolved = check_resources(&env, &profile(&unit)).unwrap();
+    assert_eq!(resolved.program.groups.len(), 2);
+  }
+
+  #[test]
+  fn fields_are_derived_from_constructor_interfaces() {
+    let (env, unit) = unit_env();
+    let unique =
+      BinderContract { uses: Uses::Many, value: ValueContract::unique() };
+    let typ = Expr::all_contract(
+      unique,
+      ValueContract::unique(),
+      Expr::reference(0, vec![]),
+      Expr::rec(0, vec![]),
+    );
+    let block = store(
+      &env,
+      Constant::with_tables(
+        ConstantInfo::Muts(vec![MutConst::Indc(Inductive {
+          is_unsafe: false,
+          lvls: 0,
+          params: 0,
+          indices: 0,
+          typ: Expr::sort(0),
+          ctors: vec![Constructor {
+            is_unsafe: false,
+            lvls: 0,
+            cidx: 0,
+            params: 0,
+            fields: 1,
+            typ,
+          }],
+        })]),
+        vec![],
+        vec![unit.clone()],
+        vec![Univ::zero()],
+      ),
+    );
+    let nominal = store(&env, indc_proj_constant(0, block.clone()));
+    store(&env, ctor_proj_constant(0, 0, block));
+    let resolved = check_resources(&env, &profile(&unit)).unwrap();
+    assert_eq!(resolved.program.fields.len(), 1);
+    let field = &resolved.program.fields[0];
+    assert_eq!(
+      resolved.addresses[usize::try_from(field.type_ref).unwrap()],
+      nominal
+    );
+    assert_eq!(field.contract, ValueContract::unique());
+  }
+
+  #[test]
+  fn canonical_cross_language_fixtures() {
+    let (_, unit) = unit_env();
+    let cases = [
+      ("unit", unit_block()),
+      (
+        "identity",
+        identity(&unit, linear_local(), ValueContract::local_shared()),
+      ),
+      (
+        "identity_unique",
+        identity(
+          &unit,
+          BinderContract { uses: Uses::Linear, value: ValueContract::unique() },
+          ValueContract::unique(),
+        ),
+      ),
+    ];
+    let fixture =
+      include_str!("../../../../Tests/Fixtures/ixon-v3/addressed.tsv");
+    for (name, constant) in cases {
+      let (address, bytes) = constant.commit();
+      let hex: String = bytes.iter().map(|b| format!("{b:02x}")).collect();
+      let line = format!("{name}\t{}\t{hex}", address.hex());
+      assert!(fixture.lines().any(|s| s == line), "fixture mismatch: {line}");
+    }
+    let p = profile(&unit);
+    let hex: String = p.bytes().iter().map(|b| format!("{b:02x}")).collect();
+    let line = format!("profile\t{}\t{hex}", p.address().unwrap().hex());
+    assert!(
+      fixture.lines().any(|s| s == line),
+      "profile fixture mismatch: {line}"
+    );
+    let bytes = p.bytes();
+    assert_eq!(Profile::from_bytes(&bytes).unwrap(), p);
+    for length in 0..bytes.len() {
+      assert!(Profile::from_bytes(&bytes[..length]).is_err());
+    }
+    let mut trailing = bytes.clone();
+    trailing.push(0);
+    assert!(Profile::from_bytes(&trailing).is_err());
+    let mut wrong_validator = bytes;
+    wrong_validator[0] ^= 1;
+    assert!(Profile::from_bytes(&wrong_validator).is_err());
+  }
+}
diff --git a/crates/ixon/src/serialize.rs b/crates/ixon/src/serialize.rs
index c45e9217e..20e6ea25c 100644
--- a/crates/ixon/src/serialize.rs
+++ b/crates/ixon/src/serialize.rs
@@ -17,7 +17,11 @@ use super::constant::{
   Definition, DefinitionProj, Inductive, InductiveProj, MutConst, Quotient,
   Recursor, RecursorProj, RecursorRule,
 };
-use super::expr::{Expr, Owned, Uses};
+use super::contract::{
+  BinderContract, LetContract, ValueContract, get_binder_contract,
+  pack_all_contract, put_binder_contract, unpack_all_contract,
+};
+use super::expr::Expr;
 use super::metadata::IxonByteSerde;
 use super::tag::{Tag0, Tag4};
 use super::univ::{Univ, get_univ, put_univ};
@@ -38,7 +42,7 @@ fn put_u8(x: u8, buf: &mut Vec<u8>) {
   buf.push(x);
 }
 
-fn get_u8(buf: &mut &[u8]) -> Result<u8, String> {
+pub(crate) fn get_u8(buf: &mut &[u8]) -> Result<u8, String> {
   match buf.split_first() {
     Some((&x, rest)) => {
       *buf = rest;
@@ -341,378 +345,289 @@ pub fn unpack_bools(n: usize, b: u8) -> Vec<bool> {
 // Expression serialization
 // ============================================================================
 
-/// Serialize an expression to bytes (iterative to avoid stack overflow).
+/// Serialize maximal ordinary telescopes without recursive host-stack calls.
 pub fn put_expr(e: &Expr, buf: &mut Vec<u8>) {
-  enum PutExprFrame<'a> {
+  enum Work<'a> {
     Expr(&'a Expr),
-    Mode(u8),
-  }
-
-  let mut stack = vec![PutExprFrame::Expr(e)];
-
-  while let Some(frame) = stack.pop() {
-    let curr = match frame {
-      PutExprFrame::Expr(curr) => curr,
-      PutExprFrame::Mode(mode) => {
-        put_u8(mode, buf);
+    Byte(u8),
+  }
+  let mut work = vec![Work::Expr(e)];
+  while let Some(next) = work.pop() {
+    let e = match next {
+      Work::Expr(e) => e,
+      Work::Byte(b) => {
+        buf.push(b);
         continue;
       },
     };
-    match curr {
-      Expr::Sort(univ_idx) => {
-        Tag4::new(Expr::FLAG_SORT, *univ_idx).put(buf);
-      },
-      Expr::Var(idx) => {
-        Tag4::new(Expr::FLAG_VAR, *idx).put(buf);
-      },
-      Expr::Ref(ref_idx, univ_indices) => {
-        Tag4::new(Expr::FLAG_REF, univ_indices.len() as u64).put(buf);
-        put_u64(*ref_idx, buf);
-        for idx in univ_indices {
-          put_u64(*idx, buf);
-        }
-      },
-      Expr::Rec(rec_idx, univ_indices) => {
-        Tag4::new(Expr::FLAG_REC, univ_indices.len() as u64).put(buf);
-        put_u64(*rec_idx, buf);
-        for idx in univ_indices {
-          put_u64(*idx, buf);
+    match e {
+      Expr::Sort(n) => Tag4::new(Expr::FLAG_SORT, *n).put(buf),
+      Expr::Var(n) => Tag4::new(Expr::FLAG_VAR, *n).put(buf),
+      Expr::Str(n) => Tag4::new(Expr::FLAG_STR, *n).put(buf),
+      Expr::Nat(n) => Tag4::new(Expr::FLAG_NAT, *n).put(buf),
+      Expr::Share(n) => Tag4::new(Expr::FLAG_SHARE, *n).put(buf),
+      Expr::Ref(n, levels) | Expr::Rec(n, levels) => {
+        Tag4::new(
+          if matches!(e, Expr::Ref(..)) {
+            Expr::FLAG_REF
+          } else {
+            Expr::FLAG_REC
+          },
+          levels.len() as u64,
+        )
+        .put(buf);
+        put_u64(*n, buf);
+        for level in levels {
+          put_u64(*level, buf);
         }
       },
-      Expr::Prj(type_ref_idx, field_idx, val) => {
-        Tag4::new(Expr::FLAG_PRJ, *field_idx).put(buf);
-        put_u64(*type_ref_idx, buf);
-        stack.push(PutExprFrame::Expr(val));
-      },
-      Expr::Str(ref_idx) => {
-        Tag4::new(Expr::FLAG_STR, *ref_idx).put(buf);
-      },
-      Expr::Nat(ref_idx) => {
-        Tag4::new(Expr::FLAG_NAT, *ref_idx).put(buf);
+      Expr::Prj(t, field, value) => {
+        Tag4::new(Expr::FLAG_PRJ, *field).put(buf);
+        put_u64(*t, buf);
+        work.push(Work::Expr(value));
       },
       Expr::App(..) => {
-        // Telescope compression: count nested apps
-        let count = curr.app_telescope_count();
-        Tag4::new(Expr::FLAG_APP, count).put(buf);
-        // Collect function and args
-        let mut e = curr;
-        let mut args = Vec::with_capacity(count as usize);
-        while let Expr::App(func, arg) = e {
-          args.push(arg.as_ref());
-          e = func.as_ref();
+        Tag4::new(Expr::FLAG_APP, e.app_telescope_count()).put(buf);
+        let mut head = e;
+        while let Expr::App(f, a) = head {
+          work.push(Work::Expr(a));
+          head = f;
         }
-        // Push in reverse order: args (reversed back to normal), then func
-        for arg in &args {
-          stack.push(PutExprFrame::Expr(arg));
-        }
-        stack.push(PutExprFrame::Expr(e)); // func last, processed first
+        work.push(Work::Expr(head));
       },
-      Expr::Lam(..) => {
-        // Telescope compression: count nested lambdas
-        let count = curr.lam_telescope_count();
-        Tag4::new(Expr::FLAG_LAM, count).put(buf);
-        // Collect types and body
-        let mut e = curr;
-        let mut binders = Vec::with_capacity(count as usize);
-        while let Expr::Lam(uses, t, b) = e {
-          binders.push((*uses, t.as_ref()));
-          e = b.as_ref();
-        }
-        // Each binder is encoded as its mode byte followed by its type.
-        stack.push(PutExprFrame::Expr(e)); // body
-        for (uses, ty) in binders.into_iter().rev() {
-          stack.push(PutExprFrame::Expr(ty));
-          stack.push(PutExprFrame::Mode(uses.to_bits()));
-        }
-      },
-      Expr::All(..) => {
-        // Telescope compression: count nested foralls
-        let count = curr.all_telescope_count();
-        Tag4::new(Expr::FLAG_ALL, count).put(buf);
-        // Collect types and body
-        let mut e = curr;
-        let mut binders = Vec::with_capacity(count as usize);
-        while let Expr::All(uses, owned, t, b) = e {
-          binders.push((*uses, *owned, t.as_ref()));
-          e = b.as_ref();
-        }
-        // Uses occupies bits 0-1 and Owned occupies bit 2.
-        stack.push(PutExprFrame::Expr(e)); // body
-        for (uses, owned, ty) in binders.into_iter().rev() {
-          stack.push(PutExprFrame::Expr(ty));
-          stack
-            .push(PutExprFrame::Mode(uses.to_bits() | (owned.to_bits() << 2)));
+      Expr::Lam(..) | Expr::All(..) => {
+        let all = matches!(e, Expr::All(..));
+        Tag4::new(
+          if all { Expr::FLAG_ALL } else { Expr::FLAG_LAM },
+          if all { e.all_telescope_count() } else { e.lam_telescope_count() },
+        )
+        .put(buf);
+        let mut body = e;
+        let mut binders = vec![];
+        loop {
+          match body {
+            Expr::Lam(c, ty, b) if !all => {
+              binders.extend([Work::Byte(c.to_bits()), Work::Expr(ty)]);
+              body = b;
+            },
+            Expr::All(c, v, ty, b) if all => {
+              binders.extend([
+                Work::Byte(pack_all_contract(*c, *v)),
+                Work::Expr(ty),
+              ]);
+              body = b;
+            },
+            _ => break,
+          }
         }
+        work.push(Work::Expr(body));
+        work.extend(binders.into_iter().rev());
       },
-      Expr::Let(non_dep, ty, val, body) => {
-        // size=0 for dep, size=1 for non_dep
-        Tag4::new(Expr::FLAG_LET, if *non_dep { 1 } else { 0 }).put(buf);
-        stack.push(PutExprFrame::Expr(body)); // Process body last
-        stack.push(PutExprFrame::Expr(val));
-        stack.push(PutExprFrame::Expr(ty)); // Process ty first
-      },
-      Expr::Share(idx) => {
-        Tag4::new(Expr::FLAG_SHARE, *idx).put(buf);
+      Expr::Let(c, ty, value, body) => {
+        Tag4::new(Expr::FLAG_LET, c.flags()).put(buf);
+        put_binder_contract(&c.binder, buf);
+        work.extend([Work::Expr(body), Work::Expr(value), Work::Expr(ty)]);
       },
     }
   }
 }
 
-/// Frame for iterative expression deserialization.
+type BinderGroup = (BinderContract, Option<ValueContract>, Arc<Expr>);
+
 enum GetExprFrame {
-  /// Parse an expression from the buffer
   Parse,
-  /// Build Prj with stored idx, pop val and typ
-  BuildPrj(u64, u64), // type_ref_idx, field_idx
-  /// Build App: pop func and arg, push App(func, arg)
-  BuildApp,
-  /// Reject a nested App base before collecting the flattened arguments.
-  CheckAppBase(u64),
-  /// Collect n more args for App telescope, then wrap
-  CollectApps(u64),
-  /// Collect remaining Lam types: have `collected`, need `remaining` more
-  CollectLamType {
-    collected: Vec<(Uses, Arc<Expr>)>,
+  Prj(u64, u64),
+  App,
+  CheckApp(u64),
+  Apps(u64),
+  Groups {
+    all: bool,
+    groups: Vec<BinderGroup>,
     remaining: u64,
-    uses: Uses,
   },
-  /// Build Lam telescope: wrap body in Lams using stored types
-  BuildLams(Vec<(Uses, Arc<Expr>)>),
-  /// Collect remaining All types: have `collected`, need `remaining` more
-  CollectAllType {
-    collected: Vec<(Uses, Owned, Arc<Expr>)>,
+  Domain {
+    all: bool,
+    groups: Vec<BinderGroup>,
     remaining: u64,
-    uses: Uses,
-    owned: Owned,
+    binder: BinderContract,
+    result: Option<ValueContract>,
+  },
+  Binders {
+    all: bool,
+    groups: Vec<BinderGroup>,
   },
-  /// Build All telescope: wrap body in Alls using stored types
-  BuildAlls(Vec<(Uses, Owned, Arc<Expr>)>),
-  /// Build Let with stored non_dep flag
-  BuildLet(bool),
+  Let(LetContract),
 }
 
-/// Deserialize an expression from bytes (iterative to avoid stack overflow).
+/// Bounded iterative decoding with canonical telescope and contract checks.
+/// Type, scope, and resource validity are separate admission obligations.
 pub fn get_expr(buf: &mut &[u8]) -> Result<Arc<Expr>, String> {
-  let mut work: Vec<GetExprFrame> = vec![GetExprFrame::Parse];
-  let mut results: Vec<Arc<Expr>> = Vec::new();
-
-  while let Some(frame) = work.pop() {
-    match frame {
+  let mut work = vec![GetExprFrame::Parse];
+  let mut results: Vec<Arc<Expr>> = vec![];
+  while let Some(next) = work.pop() {
+    match next {
       GetExprFrame::Parse => {
         let tag = Tag4::get(buf)?;
         match tag.flag {
-          Expr::FLAG_SORT => {
-            results.push(Expr::sort(tag.size));
-          },
-          Expr::FLAG_VAR => {
-            results.push(Expr::var(tag.size));
-          },
-          Expr::FLAG_REF => {
-            let ref_idx = get_u64(buf)?;
-            let mut univ_indices =
-              Vec::with_capacity(capped_capacity(tag.size, buf));
-            for _ in 0..tag.size {
-              univ_indices.push(get_u64(buf)?);
+          Expr::FLAG_SORT => results.push(Expr::sort(tag.size)),
+          Expr::FLAG_VAR => results.push(Expr::var(tag.size)),
+          Expr::FLAG_STR => results.push(Expr::str(tag.size)),
+          Expr::FLAG_NAT => results.push(Expr::nat(tag.size)),
+          Expr::FLAG_SHARE => results.push(Expr::share(tag.size)),
+          Expr::FLAG_REF | Expr::FLAG_REC => {
+            let index = get_u64(buf)?;
+            if tag.size > buf.len() as u64 {
+              return Err(
+                "get_expr: universe count exceeds remaining bytes".into(),
+              );
             }
-            results.push(Expr::reference(ref_idx, univ_indices));
-          },
-          Expr::FLAG_REC => {
-            let rec_idx = get_u64(buf)?;
-            let mut univ_indices =
-              Vec::with_capacity(capped_capacity(tag.size, buf));
+            let mut levels = Vec::with_capacity(tag.size as usize);
             for _ in 0..tag.size {
-              univ_indices.push(get_u64(buf)?);
+              levels.push(get_u64(buf)?);
             }
-            results.push(Expr::rec(rec_idx, univ_indices));
+            results.push(if tag.flag == Expr::FLAG_REF {
+              Expr::reference(index, levels)
+            } else {
+              Expr::rec(index, levels)
+            });
           },
           Expr::FLAG_PRJ => {
-            let type_ref_idx = get_u64(buf)?;
-            // Parse val, then build Prj
-            work.push(GetExprFrame::BuildPrj(type_ref_idx, tag.size));
-            work.push(GetExprFrame::Parse); // val
-          },
-          Expr::FLAG_STR => {
-            results.push(Expr::str(tag.size));
-          },
-          Expr::FLAG_NAT => {
-            results.push(Expr::nat(tag.size));
+            work.extend([
+              GetExprFrame::Prj(get_u64(buf)?, tag.size),
+              GetExprFrame::Parse,
+            ]);
           },
-          Expr::FLAG_APP => {
+          Expr::FLAG_APP | Expr::FLAG_LAM | Expr::FLAG_ALL => {
             if tag.size == 0 {
-              return Err("get_expr: empty app spine".to_string());
+              return Err("get_expr: empty telescope".into());
             }
-            // Parse func, then collect args and wrap
-            work.push(GetExprFrame::CheckAppBase(tag.size));
-            work.push(GetExprFrame::Parse); // func
-          },
-          Expr::FLAG_LAM => {
-            if tag.size == 0 {
-              return Err("get_expr: Lam with zero binders".to_string());
+            let minimum = if tag.flag == Expr::FLAG_APP { 1 } else { 2 };
+            if tag.size > (buf.len() / minimum) as u64 {
+              return Err(
+                "get_expr: telescope count exceeds remaining bytes".into(),
+              );
             }
-            let mode = get_u8(buf)?;
-            let uses = Uses::from_bits(mode)
-              .ok_or_else(|| format!("get_expr: invalid lambda mode {mode}"))?;
-            // Start collecting types
-            work.push(GetExprFrame::CollectLamType {
-              collected: Vec::new(),
-              remaining: tag.size,
-              uses,
-            });
-            work.push(GetExprFrame::Parse); // first type
-          },
-          Expr::FLAG_ALL => {
-            if tag.size == 0 {
-              return Err("get_expr: All with zero binders".to_string());
-            }
-            let mode = get_u8(buf)?;
-            if mode > 0b111 {
-              return Err(format!("get_expr: invalid forall mode {mode}"));
+            if tag.flag == Expr::FLAG_APP {
+              work.extend([
+                GetExprFrame::CheckApp(tag.size),
+                GetExprFrame::Parse,
+              ]);
+            } else {
+              work.push(GetExprFrame::Groups {
+                all: tag.flag == Expr::FLAG_ALL,
+                groups: vec![],
+                remaining: tag.size,
+              });
             }
-            let uses = Uses::from_bits(mode & 0b11)
-              .ok_or_else(|| format!("get_expr: invalid forall mode {mode}"))?;
-            let owned = Owned::from_bits((mode >> 2) & 0b1)
-              .ok_or_else(|| format!("get_expr: invalid forall mode {mode}"))?;
-            // Start collecting types
-            work.push(GetExprFrame::CollectAllType {
-              collected: Vec::new(),
-              remaining: tag.size,
-              uses,
-              owned,
-            });
-            work.push(GetExprFrame::Parse); // first type
           },
           Expr::FLAG_LET => {
-            // size=0 for dep, size=1 for non_dep
-            if tag.size > 1 {
-              return Err(format!(
-                "get_expr: invalid letE nonDep {}",
-                tag.size
-              ));
+            if tag.size > 3 {
+              return Err("get_expr: invalid let flags".into());
             }
-            let non_dep = tag.size == 1;
-            work.push(GetExprFrame::BuildLet(non_dep));
-            work.push(GetExprFrame::Parse); // body
-            work.push(GetExprFrame::Parse); // val
-            work.push(GetExprFrame::Parse); // ty
+            let binder = get_binder_contract(buf)?;
+            let contract = LetContract::from_flags(tag.size, binder)
+              .ok_or("get_expr: invalid let flags")?;
+            work.extend([
+              GetExprFrame::Let(contract),
+              GetExprFrame::Parse,
+              GetExprFrame::Parse,
+              GetExprFrame::Parse,
+            ]);
           },
-          Expr::FLAG_SHARE => {
-            results.push(Expr::share(tag.size));
-          },
-          f => return Err(format!("get_expr: invalid flag {f}")),
+          other => return Err(format!("get_expr: invalid flag {other}")),
         }
       },
-      GetExprFrame::BuildPrj(type_ref_idx, field_idx) => {
-        let val = results.pop().ok_or("get_expr: missing val for Prj")?;
-        results.push(Expr::prj(type_ref_idx, field_idx, val));
+      GetExprFrame::Prj(t, field) => {
+        let value =
+          results.pop().ok_or("get_expr: missing projection value")?;
+        results.push(Expr::prj(t, field, value));
       },
-      GetExprFrame::BuildApp => {
-        let arg = results.pop().ok_or("get_expr: missing arg for App")?;
-        let func = results.pop().ok_or("get_expr: missing func for App")?;
-        results.push(Expr::app(func, arg));
+      GetExprFrame::App => {
+        let arg = results.pop().ok_or("get_expr: missing argument")?;
+        let fun = results.pop().ok_or("get_expr: missing function")?;
+        results.push(Expr::app(fun, arg));
       },
-      GetExprFrame::CheckAppBase(remaining) => {
-        let base =
-          results.last().ok_or("get_expr: missing base for App telescope")?;
-        if matches!(base.as_ref(), Expr::App(..)) {
-          return Err("get_expr: non-canonical app base".to_string());
+      GetExprFrame::CheckApp(remaining) => {
+        if matches!(results.last().map(|e| e.as_ref()), Some(Expr::App(..))) {
+          return Err("get_expr: non-canonical app base".into());
         }
-        work.push(GetExprFrame::CollectApps(remaining));
+        work.push(GetExprFrame::Apps(remaining));
       },
-      GetExprFrame::CollectApps(remaining) => {
-        if remaining == 0 {
-          // All args collected, result is already on stack
-        } else {
-          // Parse next arg, apply to current func
-          work.push(GetExprFrame::CollectApps(remaining - 1));
-          work.push(GetExprFrame::BuildApp);
-          work.push(GetExprFrame::Parse); // arg
+      GetExprFrame::Apps(remaining) => {
+        if remaining > 0 {
+          work.extend([
+            GetExprFrame::Apps(remaining - 1),
+            GetExprFrame::App,
+            GetExprFrame::Parse,
+          ]);
         }
       },
-      GetExprFrame::CollectLamType { mut collected, remaining, uses } => {
-        // Pop the just-parsed type
-        let ty = results.pop().ok_or("get_expr: missing type for Lam")?;
-        collected.push((uses, ty));
-
-        if remaining > 1 {
-          // More types to collect
-          let mode = get_u8(buf)?;
-          let uses = Uses::from_bits(mode)
-            .ok_or_else(|| format!("get_expr: invalid lambda mode {mode}"))?;
-          work.push(GetExprFrame::CollectLamType {
-            collected,
-            remaining: remaining - 1,
-            uses,
-          });
-          work.push(GetExprFrame::Parse); // next type
+      GetExprFrame::Groups { all, groups, remaining } => {
+        if remaining == 0 {
+          work.extend([
+            GetExprFrame::Binders { all, groups },
+            GetExprFrame::Parse,
+          ]);
         } else {
-          // All types collected, now parse body
-          work.push(GetExprFrame::BuildLams(collected));
-          work.push(GetExprFrame::Parse); // body
-        }
-      },
-      GetExprFrame::BuildLams(types) => {
-        let mut body = results.pop().ok_or("get_expr: missing body for Lam")?;
-        if matches!(body.as_ref(), Expr::Lam(..)) {
-          return Err("get_expr: non-canonical lam telescope".to_string());
-        }
-        for (uses, ty) in types.into_iter().rev() {
-          body = Expr::lam_mode(uses, ty, body);
+          let bits = get_u8(buf)?;
+          let (binder, result) = if all {
+            let (binder, result) =
+              unpack_all_contract(bits).ok_or_else(|| {
+                format!("get_expr: invalid forall contract {bits}")
+              })?;
+            (binder, Some(result))
+          } else {
+            (
+              BinderContract::from_bits(bits).ok_or_else(|| {
+                format!("get_expr: invalid lambda contract {bits}")
+              })?,
+              None,
+            )
+          };
+          work.extend([
+            GetExprFrame::Domain {
+              all,
+              groups,
+              remaining: remaining - 1,
+              binder,
+              result,
+            },
+            GetExprFrame::Parse,
+          ]);
         }
-        results.push(body);
       },
-      GetExprFrame::CollectAllType {
-        mut collected,
-        remaining,
-        uses,
-        owned,
-      } => {
-        // Pop the just-parsed type
-        let ty = results.pop().ok_or("get_expr: missing type for All")?;
-        collected.push((uses, owned, ty));
-
-        if remaining > 1 {
-          // More types to collect
-          let mode = get_u8(buf)?;
-          if mode > 0b111 {
-            return Err(format!("get_expr: invalid forall mode {mode}"));
-          }
-          let uses = Uses::from_bits(mode & 0b11)
-            .ok_or_else(|| format!("get_expr: invalid forall mode {mode}"))?;
-          let owned = Owned::from_bits((mode >> 2) & 0b1)
-            .ok_or_else(|| format!("get_expr: invalid forall mode {mode}"))?;
-          work.push(GetExprFrame::CollectAllType {
-            collected,
-            remaining: remaining - 1,
-            uses,
-            owned,
-          });
-          work.push(GetExprFrame::Parse); // next type
-        } else {
-          // All types collected, now parse body
-          work.push(GetExprFrame::BuildAlls(collected));
-          work.push(GetExprFrame::Parse); // body
-        }
+      GetExprFrame::Domain { all, mut groups, remaining, binder, result } => {
+        let ty = results.pop().ok_or("get_expr: missing binder domain")?;
+        groups.push((binder, result, ty));
+        work.push(GetExprFrame::Groups { all, groups, remaining });
       },
-      GetExprFrame::BuildAlls(types) => {
-        let mut body = results.pop().ok_or("get_expr: missing body for All")?;
-        if matches!(body.as_ref(), Expr::All(..)) {
-          return Err("get_expr: non-canonical all telescope".to_string());
+      GetExprFrame::Binders { all, groups } => {
+        let mut body = results.pop().ok_or("get_expr: missing binder body")?;
+        if (all && matches!(body.as_ref(), Expr::All(..)))
+          || (!all && matches!(body.as_ref(), Expr::Lam(..)))
+        {
+          return Err("get_expr: non-canonical binder telescope".into());
         }
-        for (uses, owned, ty) in types.into_iter().rev() {
-          body = Expr::all_mode(uses, owned, ty, body);
+        for (contract, result, ty) in groups.into_iter().rev() {
+          body = match result {
+            Some(result) => Expr::all_contract(contract, result, ty, body),
+            None => Expr::lam_contract(contract, ty, body),
+          };
         }
         results.push(body);
       },
-      GetExprFrame::BuildLet(non_dep) => {
-        let body = results.pop().ok_or("get_expr: missing body for Let")?;
-        let val = results.pop().ok_or("get_expr: missing val for Let")?;
-        let ty = results.pop().ok_or("get_expr: missing ty for Let")?;
-        results.push(Expr::let_(non_dep, ty, val, body));
+      GetExprFrame::Let(contract) => {
+        let body = results.pop().ok_or("get_expr: missing let body")?;
+        let value = results.pop().ok_or("get_expr: missing let value")?;
+        let ty = results.pop().ok_or("get_expr: missing let type")?;
+        results.push(Expr::let_contract(contract, ty, value, body));
       },
     }
   }
-
-  results.pop().ok_or_else(|| "get_expr: no result".to_string())
+  if results.len() != 1 {
+    return Err("get_expr: invalid result stack".into());
+  }
+  results.pop().ok_or_else(|| "get_expr: no result".into())
 }
 
 // ============================================================================
@@ -853,7 +768,11 @@ impl Recursor {
   }
 
   pub fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let bools = unpack_bools(2, get_u8(buf)?);
+    let flags = get_u8(buf)?;
+    if flags > 3 {
+      return Err("invalid recursor flags".into());
+    }
+    let bools = unpack_bools(2, flags);
     let lvls = get_u64(buf)?;
     let params = get_u64(buf)?;
     let indices = get_u64(buf)?;
@@ -944,7 +863,7 @@ impl Inductive {
   }
 
   pub fn get(buf: &mut &[u8]) -> Result<Self, String> {
-    let bools = unpack_bools(1, get_u8(buf)?);
+    let bools = [get_bool(buf)?];
     let lvls = get_u64(buf)?;
     let params = get_u64(buf)?;
     let indices = get_u64(buf)?;
@@ -1627,7 +1546,7 @@ impl Env {
   /// back-compat reading of old versions — `.ixe` files are
   /// regenerated artifacts. Mirrors `Ixon.Env.VERSION` in
   /// `Ix/Ixon.lean`.
-  pub const VERSION: u64 = 2;
+  pub const VERSION: u64 = 3;
 
   /// Serialize an Env to bytes.
   ///
@@ -3348,22 +3267,226 @@ mod tests {
   use quickcheck::{Arbitrary, Gen};
   use quickcheck_macros::quickcheck;
 
+  fn v3_fixture_exprs() -> Vec<(&'static str, Arc<Expr>)> {
+    use crate::contract::LetKind;
+    use crate::expr::Uses;
+    let binder = |uses, value| BinderContract { uses, value };
+    vec![
+      (
+        "app",
+        Expr::app(
+          Expr::app(Expr::app(Expr::var(3), Expr::var(2)), Expr::var(1)),
+          Expr::var(0),
+        ),
+      ),
+      (
+        "lam",
+        Expr::lam(
+          Expr::sort(0),
+          Expr::lam(Expr::sort(0), Expr::lam(Expr::sort(0), Expr::var(0))),
+        ),
+      ),
+      (
+        "lam_local_unique",
+        Expr::lam_contract(
+          binder(Uses::Linear, ValueContract::local_unique()),
+          Expr::sort(0),
+          Expr::var(0),
+        ),
+      ),
+      (
+        "lam_affine_local",
+        Expr::lam_contract(
+          binder(Uses::Affine, ValueContract::local_shared()),
+          Expr::sort(0),
+          Expr::var(0),
+        ),
+      ),
+      (
+        "all",
+        Expr::all_contract(
+          binder(Uses::Linear, ValueContract::local_unique()),
+          ValueContract::local_unique(),
+          Expr::sort(0),
+          Expr::all(Expr::sort(0), Expr::var(0)),
+        ),
+      ),
+      (
+        "ordinary_let",
+        Expr::let_contract(
+          LetContract {
+            non_dep: true,
+            kind: LetKind::Value,
+            binder: binder(Uses::Erased, ValueContract::unique()),
+          },
+          Expr::sort(0),
+          Expr::nat(1),
+          Expr::var(0),
+        ),
+      ),
+      (
+        "local_unique_let",
+        Expr::let_contract(
+          LetContract {
+            non_dep: false,
+            kind: LetKind::Value,
+            binder: binder(Uses::Affine, ValueContract::local_unique()),
+          },
+          Expr::sort(0),
+          Expr::var(1),
+          Expr::var(0),
+        ),
+      ),
+      (
+        "borrow",
+        Expr::let_contract(
+          LetContract::borrow(false, Uses::Affine),
+          Expr::sort(0),
+          Expr::prj(2, 1, Expr::var(1)),
+          Expr::var(0),
+        ),
+      ),
+      (
+        "borrow_nondep",
+        Expr::let_contract(
+          LetContract::borrow(true, Uses::Many),
+          Expr::sort(0),
+          Expr::var(1),
+          Expr::var(0),
+        ),
+      ),
+      ("reference", Expr::reference(0, vec![])),
+      ("recursion", Expr::rec(2, vec![0, 1])),
+    ]
+  }
+
+  #[test]
+  fn v3_independent_golden_expressions() {
+    let file = include_str!("../../../Tests/Fixtures/ixon-v3/expressions.txt");
+    for (name, expr) in v3_fixture_exprs() {
+      let line = file
+        .lines()
+        .find(|line| line.starts_with(&format!("{name} ")))
+        .unwrap();
+      let hex = line.split_whitespace().nth(1).unwrap();
+      let expected: Vec<_> = hex
+        .as_bytes()
+        .as_chunks::<2>()
+        .0
+        .iter()
+        .map(|pair| {
+          u8::from_str_radix(std::str::from_utf8(pair).unwrap(), 16).unwrap()
+        })
+        .collect();
+      let mut actual = vec![];
+      put_expr(&expr, &mut actual);
+      assert_eq!(actual, expected, "{name}");
+      let mut input = expected.as_slice();
+      assert_eq!(get_expr(&mut input).unwrap(), expr, "{name}");
+      assert!(input.is_empty(), "{name}: unread bytes");
+      for end in 0..expected.len() {
+        assert!(
+          get_expr(&mut &expected[..end]).is_err(),
+          "{name}: accepted truncation at {end}"
+        );
+      }
+    }
+  }
+
+  #[test]
+  fn v3_exhaustive_mode_bytes_and_hashes() {
+    use crate::contract::LetKind;
+    use crate::expr::Uses;
+    let values = [
+      ValueContract::unique(),
+      ValueContract::shared(),
+      ValueContract::local_unique(),
+      ValueContract::local_shared(),
+    ];
+    let uses = [Uses::Erased, Uses::Linear, Uses::Affine, Uses::Many];
+    let mut hashes = std::collections::HashSet::new();
+    for (value_code, value) in values.into_iter().enumerate() {
+      for (use_code, uses) in uses.into_iter().enumerate() {
+        let input = BinderContract { uses, value };
+        let input_code = (use_code + 4 * value_code) as u8;
+        let lam = Expr::lam_contract(input, Expr::sort(0), Expr::var(0));
+        let mut bytes = vec![];
+        put_expr(&lam, &mut bytes);
+        assert_eq!(bytes, [0x81, input_code, 0x00, 0x10]);
+        assert_eq!(get_expr(&mut bytes.as_slice()).unwrap(), lam);
+        assert!(hashes.insert(crate::sharing::hash_expr(&lam)));
+        for (result_code, result) in values.into_iter().enumerate() {
+          let all =
+            Expr::all_contract(input, result, Expr::sort(0), Expr::var(0));
+          let mut bytes = vec![];
+          put_expr(&all, &mut bytes);
+          assert_eq!(
+            bytes,
+            [0x91, input_code + 16 * result_code as u8, 0x00, 0x10]
+          );
+          assert_eq!(get_expr(&mut bytes.as_slice()).unwrap(), all);
+          assert!(hashes.insert(crate::sharing::hash_expr(&all)));
+        }
+        for non_dep in [false, true] {
+          for kind in [LetKind::Value, LetKind::BorrowShared] {
+            let let_expr = Expr::let_contract(
+              LetContract { non_dep, kind, binder: input },
+              Expr::sort(0),
+              Expr::var(1),
+              Expr::var(0),
+            );
+            let mut bytes = vec![];
+            put_expr(&let_expr, &mut bytes);
+            assert_eq!(
+              bytes,
+              [
+                0xA0
+                  + u8::from(non_dep)
+                  + if kind == LetKind::BorrowShared { 2 } else { 0 },
+                input_code,
+                0x00,
+                0x11,
+                0x10
+              ]
+            );
+            assert_eq!(get_expr(&mut bytes.as_slice()).unwrap(), let_expr);
+            assert!(hashes.insert(crate::sharing::hash_expr(&let_expr)));
+          }
+        }
+      }
+    }
+    assert_eq!(hashes.len(), 16 + 64 + 64);
+  }
+
   #[test]
-  fn rejects_noncanonical_v2_exprs() {
+  fn rejects_noncanonical_v3_exprs() {
     let malformed: &[&[u8]] = &[
       &[0x70],
-      &[0x71, 0x71, 0x10, 0x11, 0x12],
-      &[0x81, 0x03, 0x00, 0x81, 0x03, 0x00, 0x10],
-      &[0x91, 0x07, 0x00, 0x91, 0x07, 0x00, 0x10],
-      &[0xA2],
-      &[0x81, 0x04],
-      &[0x91, 0x08],
+      &[0x80],
+      &[0x90],                                     // empty telescopes
+      &[0x71, 0x71, 0x10, 0x11, 0x12],             // nonmaximal application
+      &[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10], // nonmaximal lambda
+      &[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10], // nonmaximal forall
+      &[0xA4, 0x07, 0x00, 0x10, 0x10],             // reserved let flag
+      &[0x18, 0x00],                               // nonminimal Tag4
+      &[0x28, 0x07, 0x00], // nonminimal reference telescope count
+      &[0x20, 0x80, 0x00], // nonminimal Tag0
+      &[0x87, 0x07, 0x00, 0x10], // impossible binder count
+      &[0x77, 0x10],       // impossible argument count
     ];
-
     for bytes in malformed {
       let mut input = *bytes;
       assert!(get_expr(&mut input).is_err(), "accepted {bytes:02x?}");
     }
+    for code in 16..=u8::MAX {
+      assert!(get_expr(&mut [0x81, code, 0x00, 0x10].as_slice()).is_err());
+      assert!(
+        get_expr(&mut [0xA0, code, 0x00, 0x10, 0x10].as_slice()).is_err()
+      );
+    }
+    for code in 64..=u8::MAX {
+      assert!(get_expr(&mut [0x91, code, 0x00, 0x10].as_slice()).is_err());
+    }
   }
 
   #[quickcheck]
diff --git a/crates/ixon/src/sharing.rs b/crates/ixon/src/sharing.rs
index 1d8629cf0..953c0c90e 100644
--- a/crates/ixon/src/sharing.rs
+++ b/crates/ixon/src/sharing.rs
@@ -32,181 +32,63 @@ pub struct SubtermInfo {
   pub children: Vec<blake3::Hash>,
 }
 
-/// Hash an expression node using Merkle-tree style hashing.
-/// Returns (hash, child_hashes, value_size) where value_size is the size of the
-/// serialized node value in a hash-consed store (not including the 32-byte key).
+/// Canonical scalar/contract data for one node, followed by fixed-size
+/// child hashes in structural order. All three mode axes are semantic.
+fn put_node_header(expr: &Expr, buf: &mut Vec<u8>) {
+  match expr {
+    Expr::Sort(_)
+    | Expr::Var(_)
+    | Expr::Ref(..)
+    | Expr::Rec(..)
+    | Expr::Str(_)
+    | Expr::Nat(_)
+    | Expr::Share(_) => crate::serialize::put_expr(expr, buf),
+    Expr::Prj(t, field, _) => {
+      Tag4::new(Expr::FLAG_PRJ, *field).put(buf);
+      Tag0::new(*t).put(buf);
+    },
+    Expr::App(..) => Tag4::new(Expr::FLAG_APP, 1).put(buf),
+    Expr::Lam(c, ..) => {
+      Tag4::new(Expr::FLAG_LAM, 1).put(buf);
+      buf.push(c.to_bits());
+    },
+    Expr::All(c, v, ..) => {
+      Tag4::new(Expr::FLAG_ALL, 1).put(buf);
+      buf.push(crate::contract::pack_all_contract(*c, *v));
+    },
+    Expr::Let(c, ..) => {
+      Tag4::new(Expr::FLAG_LET, c.flags()).put(buf);
+      buf.push(c.binder.to_bits());
+    },
+  }
+}
+
 fn hash_node(
   expr: &Expr,
   child_hashes: &FxHashMap<*const Expr, blake3::Hash>,
   buf: &mut Vec<u8>,
 ) -> (blake3::Hash, Vec<blake3::Hash>, usize) {
   buf.clear();
-
-  let children = match expr {
-    Expr::Sort(univ_idx) => {
-      buf.push(Expr::FLAG_SORT);
-      buf.extend_from_slice(&univ_idx.to_le_bytes());
-      vec![]
-    },
-    Expr::Var(idx) => {
-      buf.push(Expr::FLAG_VAR);
-      buf.extend_from_slice(&idx.to_le_bytes());
-      vec![]
-    },
-    Expr::Ref(ref_idx, univ_indices) => {
-      buf.push(Expr::FLAG_REF);
-      buf.extend_from_slice(&ref_idx.to_le_bytes());
-      buf.extend_from_slice(&(univ_indices.len() as u64).to_le_bytes());
-      for idx in univ_indices {
-        buf.extend_from_slice(&idx.to_le_bytes());
-      }
-      vec![]
-    },
-    Expr::Rec(rec_idx, univ_indices) => {
-      buf.push(Expr::FLAG_REC);
-      buf.extend_from_slice(&rec_idx.to_le_bytes());
-      buf.extend_from_slice(&(univ_indices.len() as u64).to_le_bytes());
-      for idx in univ_indices {
-        buf.extend_from_slice(&idx.to_le_bytes());
-      }
-      vec![]
-    },
-    Expr::Prj(type_ref_idx, field_idx, val) => {
-      buf.push(Expr::FLAG_PRJ);
-      buf.extend_from_slice(&type_ref_idx.to_le_bytes());
-      buf.extend_from_slice(&field_idx.to_le_bytes());
-      let val_ptr = val.as_ref() as *const Expr;
-      let val_hash = child_hashes.get(&val_ptr).unwrap();
-      buf.extend_from_slice(val_hash.as_bytes());
-      vec![*val_hash]
-    },
-    Expr::Str(ref_idx) => {
-      buf.push(Expr::FLAG_STR);
-      buf.extend_from_slice(&ref_idx.to_le_bytes());
-      vec![]
-    },
-    Expr::Nat(ref_idx) => {
-      buf.push(Expr::FLAG_NAT);
-      buf.extend_from_slice(&ref_idx.to_le_bytes());
-      vec![]
-    },
-    Expr::App(fun, arg) => {
-      buf.push(Expr::FLAG_APP);
-      let fun_ptr = fun.as_ref() as *const Expr;
-      let arg_ptr = arg.as_ref() as *const Expr;
-      let fun_hash = child_hashes.get(&fun_ptr).unwrap();
-      let arg_hash = child_hashes.get(&arg_ptr).unwrap();
-      buf.extend_from_slice(fun_hash.as_bytes());
-      buf.extend_from_slice(arg_hash.as_bytes());
-      vec![*fun_hash, *arg_hash]
-    },
-    Expr::Lam(uses, ty, body) => {
-      buf.push(Expr::FLAG_LAM);
-      buf.push(uses.to_bits());
-      let ty_ptr = ty.as_ref() as *const Expr;
-      let body_ptr = body.as_ref() as *const Expr;
-      let ty_hash = child_hashes.get(&ty_ptr).unwrap();
-      let body_hash = child_hashes.get(&body_ptr).unwrap();
-      buf.extend_from_slice(ty_hash.as_bytes());
-      buf.extend_from_slice(body_hash.as_bytes());
-      vec![*ty_hash, *body_hash]
-    },
-    Expr::All(uses, owned, ty, body) => {
-      buf.push(Expr::FLAG_ALL);
-      buf.push(uses.to_bits() | (owned.to_bits() << 2));
-      let ty_ptr = ty.as_ref() as *const Expr;
-      let body_ptr = body.as_ref() as *const Expr;
-      let ty_hash = child_hashes.get(&ty_ptr).unwrap();
-      let body_hash = child_hashes.get(&body_ptr).unwrap();
-      buf.extend_from_slice(ty_hash.as_bytes());
-      buf.extend_from_slice(body_hash.as_bytes());
-      vec![*ty_hash, *body_hash]
-    },
-    Expr::Let(non_dep, ty, val, body) => {
-      buf.push(Expr::FLAG_LET);
-      buf.push(if *non_dep { 1 } else { 0 }); // size field encodes non_dep
-      let ty_ptr = ty.as_ref() as *const Expr;
-      let val_ptr = val.as_ref() as *const Expr;
-      let body_ptr = body.as_ref() as *const Expr;
-      let ty_hash = child_hashes.get(&ty_ptr).unwrap();
-      let val_hash = child_hashes.get(&val_ptr).unwrap();
-      let body_hash = child_hashes.get(&body_ptr).unwrap();
-      buf.extend_from_slice(ty_hash.as_bytes());
-      buf.extend_from_slice(val_hash.as_bytes());
-      buf.extend_from_slice(body_hash.as_bytes());
-      vec![*ty_hash, *val_hash, *body_hash]
-    },
-    Expr::Share(idx) => {
-      buf.push(Expr::FLAG_SHARE);
-      buf.extend_from_slice(&idx.to_le_bytes());
-      vec![]
-    },
-  };
-
-  let value_size = buf.len();
-  (blake3::hash(buf), children, value_size)
+  put_node_header(expr, buf);
+  let children: Vec<_> = get_children(expr)
+    .iter()
+    .map(|child| {
+      let hash = child_hashes[&(child.as_ref() as *const Expr)];
+      buf.extend_from_slice(hash.as_bytes());
+      hash
+    })
+    .collect();
+  (blake3::hash(buf), children, buf.len())
 }
 
-/// Compute the base size of a node (Tag4 header size) for Ixon serialization.
 fn compute_base_size(expr: &Expr) -> usize {
-  match expr {
-    Expr::Sort(univ_idx) => {
-      Tag4::new(Expr::FLAG_SORT, *univ_idx).encoded_size()
-    },
-    Expr::Var(idx) => Tag4::new(Expr::FLAG_VAR, *idx).encoded_size(),
-    Expr::Ref(ref_idx, univ_indices) => {
-      // tag + ref_idx + N univ indices
-      Tag4::new(Expr::FLAG_REF, univ_indices.len() as u64).encoded_size()
-        + Tag0::new(*ref_idx).encoded_size()
-        + univ_indices
-          .iter()
-          .map(|i| Tag0::new(*i).encoded_size())
-          .sum::<usize>()
-    },
-    Expr::Rec(rec_idx, univ_indices) => {
-      // tag + rec_idx + N univ indices
-      Tag4::new(Expr::FLAG_REC, univ_indices.len() as u64).encoded_size()
-        + Tag0::new(*rec_idx).encoded_size()
-        + univ_indices
-          .iter()
-          .map(|i| Tag0::new(*i).encoded_size())
-          .sum::<usize>()
-    },
-    Expr::Prj(type_ref_idx, field_idx, _) => {
-      // Tag (field_idx in payload) + type_ref_idx (variable length, estimate 2 bytes)
-      Tag4::new(Expr::FLAG_PRJ, *field_idx).encoded_size()
-        + Tag0::new(*type_ref_idx).encoded_size()
-    },
-    Expr::Str(ref_idx) => Tag4::new(Expr::FLAG_STR, *ref_idx).encoded_size(),
-    Expr::Nat(ref_idx) => Tag4::new(Expr::FLAG_NAT, *ref_idx).encoded_size(),
-    Expr::App(..) => Tag4::new(Expr::FLAG_APP, 1).encoded_size(), // telescope count >= 1
-    Expr::Lam(..) => Tag4::new(Expr::FLAG_LAM, 1).encoded_size() + 1,
-    Expr::All(..) => Tag4::new(Expr::FLAG_ALL, 1).encoded_size() + 1,
-    Expr::Let(non_dep, ..) => {
-      // size=0 for dep, size=1 for non_dep
-      Tag4::new(Expr::FLAG_LET, if *non_dep { 1 } else { 0 }).encoded_size()
-    },
-    Expr::Share(idx) => Tag4::new(Expr::FLAG_SHARE, *idx).encoded_size(),
-  }
+  let mut buf = Vec::with_capacity(16);
+  put_node_header(expr, &mut buf);
+  buf.len()
 }
 
-/// Get child expressions for traversal.
 fn get_children(expr: &Expr) -> Vec<&Arc<Expr>> {
-  match expr {
-    Expr::Sort(_)
-    | Expr::Var(_)
-    | Expr::Ref(..)
-    | Expr::Rec(..)
-    | Expr::Str(_)
-    | Expr::Nat(_)
-    | Expr::Share(_) => {
-      vec![]
-    },
-    Expr::Prj(_, _, val) => vec![val],
-    Expr::App(fun, arg) => vec![fun, arg],
-    Expr::Lam(_, ty, body) | Expr::All(_, _, ty, body) => vec![ty, body],
-    Expr::Let(_, ty, val, body) => vec![ty, val, body],
-  }
+  expr.children()
 }
 
 /// Analyze expressions for sharing opportunities within a block.
@@ -676,42 +558,25 @@ pub fn build_sharing_vec(
   (rewritten_exprs, sharing_vec)
 }
 
-/// Frame for iterative rewrite traversal.
 enum RewriteFrame<'a> {
-  /// Visit an expression (check cache/share, then push children)
   Visit(&'a Arc<Expr>),
-  /// Build a Prj node from rewritten children (type_ref_idx, field_idx)
-  BuildPrj(&'a Arc<Expr>, u64, u64),
-  /// Build an App node from rewritten children
-  BuildApp(&'a Arc<Expr>),
-  /// Build a Lam node from rewritten children
-  BuildLam(&'a Arc<Expr>),
-  /// Build an All node from rewritten children
-  BuildAll(&'a Arc<Expr>),
-  /// Build a Let node from rewritten children
-  BuildLet(&'a Arc<Expr>, bool),
+  Build(&'a Arc<Expr>),
 }
 
-/// Rewrite an expression tree to use Share(idx) references.
-/// Uses iterative traversal with caching to handle deep trees and Arc sharing.
+/// Iterative reconstruction preserves every contract while changing
+/// only expression children. The hash includes every mode and let flag.
 fn rewrite_expr(
   expr: &Arc<Expr>,
   hash_to_idx: &FxHashMap<blake3::Hash, u64>,
   ptr_to_hash: &FxHashMap<*const Expr, blake3::Hash>,
   cache: &mut FxHashMap<*const Expr, Arc<Expr>>,
 ) -> Arc<Expr> {
-  let mut stack: Vec<RewriteFrame<'_>> = vec![RewriteFrame::Visit(expr)];
-  let mut results: Vec<Arc<Expr>> = Vec::new();
-
+  let mut stack = vec![RewriteFrame::Visit(expr)];
+  let mut results: Vec<Arc<Expr>> = vec![];
   while let Some(frame) = stack.pop() {
     match frame {
       RewriteFrame::Visit(e) => {
         let ptr = e.as_ref() as *const Expr;
-
-        // Check hash_to_idx FIRST: if this expression is shareable, replace
-        // it with Share(idx) even if the cache has a stale (pre-sharing)
-        // entry. This ordering eliminates the need for cache.clear() in the
-        // outer build_sharing_vec loop.
         if let Some(hash) = ptr_to_hash.get(&ptr)
           && let Some(&idx) = hash_to_idx.get(hash)
         {
@@ -720,157 +585,42 @@ fn rewrite_expr(
           results.push(share);
           continue;
         }
-
-        // Cache hit for non-shareable sub-expressions
         if let Some(cached) = cache.get(&ptr) {
           results.push(cached.clone());
           continue;
         }
-
-        // Process based on node type
-        match e.as_ref() {
-          // Leaf nodes - return as-is
-          Expr::Sort(_)
-          | Expr::Var(_)
-          | Expr::Ref(..)
-          | Expr::Rec(..)
-          | Expr::Str(_)
-          | Expr::Nat(_)
-          | Expr::Share(_) => {
-            cache.insert(ptr, e.clone());
-            results.push(e.clone());
-          },
-
-          // Nodes with children - push build frame, then visit children
-          Expr::Prj(type_ref_idx, field_idx, val) => {
-            stack.push(RewriteFrame::BuildPrj(e, *type_ref_idx, *field_idx));
-            stack.push(RewriteFrame::Visit(val));
-          },
-          Expr::App(fun, arg) => {
-            stack.push(RewriteFrame::BuildApp(e));
-            stack.push(RewriteFrame::Visit(arg));
-            stack.push(RewriteFrame::Visit(fun));
-          },
-          Expr::Lam(_, ty, body) => {
-            stack.push(RewriteFrame::BuildLam(e));
-            stack.push(RewriteFrame::Visit(body));
-            stack.push(RewriteFrame::Visit(ty));
-          },
-          Expr::All(_, _, ty, body) => {
-            stack.push(RewriteFrame::BuildAll(e));
-            stack.push(RewriteFrame::Visit(body));
-            stack.push(RewriteFrame::Visit(ty));
-          },
-          Expr::Let(non_dep, ty, val, body) => {
-            stack.push(RewriteFrame::BuildLet(e, *non_dep));
-            stack.push(RewriteFrame::Visit(body));
-            stack.push(RewriteFrame::Visit(val));
-            stack.push(RewriteFrame::Visit(ty));
-          },
-        }
-      },
-
-      RewriteFrame::BuildPrj(orig, type_ref_idx, field_idx) => {
-        let new_val = results.pop().unwrap();
-        let orig_val = match orig.as_ref() {
-          Expr::Prj(_, _, v) => v,
-          _ => unreachable!(),
-        };
-        let result = if Arc::ptr_eq(&new_val, orig_val) {
-          orig.clone()
-        } else {
-          Expr::prj(type_ref_idx, field_idx, new_val)
-        };
-        let ptr = orig.as_ref() as *const Expr;
-        cache.insert(ptr, result.clone());
-        results.push(result);
-      },
-
-      RewriteFrame::BuildApp(orig) => {
-        // Pop in reverse order of push: arg was pushed last, fun first
-        let new_arg = results.pop().unwrap();
-        let new_fun = results.pop().unwrap();
-        let (orig_fun, orig_arg) = match orig.as_ref() {
-          Expr::App(f, a) => (f, a),
-          _ => unreachable!(),
-        };
-        let result = if Arc::ptr_eq(&new_fun, orig_fun)
-          && Arc::ptr_eq(&new_arg, orig_arg)
-        {
-          orig.clone()
+        let children = get_children(e);
+        if children.is_empty() {
+          cache.insert(ptr, e.clone());
+          results.push(e.clone());
         } else {
-          Expr::app(new_fun, new_arg)
-        };
-        let ptr = orig.as_ref() as *const Expr;
-        cache.insert(ptr, result.clone());
-        results.push(result);
-      },
-
-      RewriteFrame::BuildLam(orig) => {
-        // Pop in reverse order of push: body was pushed last, ty first
-        let new_body = results.pop().unwrap();
-        let new_ty = results.pop().unwrap();
-        let (uses, orig_ty, orig_body) = match orig.as_ref() {
-          Expr::Lam(uses, t, b) => (*uses, t, b),
-          _ => unreachable!(),
-        };
-        let result = if Arc::ptr_eq(&new_ty, orig_ty)
-          && Arc::ptr_eq(&new_body, orig_body)
-        {
-          orig.clone()
-        } else {
-          Expr::lam_mode(uses, new_ty, new_body)
-        };
-        let ptr = orig.as_ref() as *const Expr;
-        cache.insert(ptr, result.clone());
-        results.push(result);
-      },
-
-      RewriteFrame::BuildAll(orig) => {
-        // Pop in reverse order of push: body was pushed last, ty first
-        let new_body = results.pop().unwrap();
-        let new_ty = results.pop().unwrap();
-        let (uses, owned, orig_ty, orig_body) = match orig.as_ref() {
-          Expr::All(uses, owned, t, b) => (*uses, *owned, t, b),
-          _ => unreachable!(),
-        };
-        let result = if Arc::ptr_eq(&new_ty, orig_ty)
-          && Arc::ptr_eq(&new_body, orig_body)
-        {
-          orig.clone()
-        } else {
-          Expr::all_mode(uses, owned, new_ty, new_body)
-        };
-        let ptr = orig.as_ref() as *const Expr;
-        cache.insert(ptr, result.clone());
-        results.push(result);
+          stack.push(RewriteFrame::Build(e));
+          stack.extend(children.into_iter().rev().map(RewriteFrame::Visit));
+        }
       },
-
-      RewriteFrame::BuildLet(orig, non_dep) => {
-        // Pop in reverse order of push: body, val, ty
-        let new_body = results.pop().unwrap();
-        let new_val = results.pop().unwrap();
-        let new_ty = results.pop().unwrap();
-        let (orig_ty, orig_val, orig_body) = match orig.as_ref() {
-          Expr::Let(_, t, v, b) => (t, v, b),
-          _ => unreachable!(),
-        };
-        let result = if Arc::ptr_eq(&new_ty, orig_ty)
-          && Arc::ptr_eq(&new_val, orig_val)
-          && Arc::ptr_eq(&new_body, orig_body)
-        {
-          orig.clone()
+      RewriteFrame::Build(original) => {
+        let children = get_children(original);
+        let start = results.len() - children.len();
+        let changed = children
+          .iter()
+          .zip(&results[start..])
+          .any(|(old, new)| !Arc::ptr_eq(old, new));
+        let rebuilt: Vec<_> = results.drain(start..).collect();
+        let result = if !changed {
+          original.clone()
         } else {
-          Expr::let_(non_dep, new_ty, new_val, new_body)
+          Arc::new(
+            original
+              .with_children(&rebuilt)
+              .expect("sharing rewrite child count"),
+          )
         };
-        let ptr = orig.as_ref() as *const Expr;
-        cache.insert(ptr, result.clone());
+        cache.insert(original.as_ref() as *const Expr, result.clone());
         results.push(result);
       },
     }
   }
-
-  results.pop().unwrap()
+  results.pop().expect("sharing rewrite result")
 }
 
 #[cfg(test)]
diff --git a/crates/ixon/src/syntax/ast.rs b/crates/ixon/src/syntax/ast.rs
index 0ffae3813..a6f8ee649 100644
--- a/crates/ixon/src/syntax/ast.rs
+++ b/crates/ixon/src/syntax/ast.rs
@@ -10,6 +10,7 @@
 //! derived `PartialEq`; roundtrip tests therefore compare at the text
 //! level (`print ∘ parse ∘ print = print`), not by AST equality.
 
+use crate::contract::{BinderContract, LetContract, ValueContract};
 use bignat::Nat;
 use ix_common::env::{BinderInfo, NameComponent};
 
@@ -120,6 +121,7 @@ impl BinderName {
 /// unnamed instance form `[C]`, `names` is empty.
 #[derive(Debug, Clone, PartialEq)]
 pub struct BinderGroup {
+  pub contract: BinderContract,
   pub info: BinderInfo,
   pub names: Vec<BinderName>,
   pub ty: Term,
@@ -139,13 +141,18 @@ pub enum Term {
   /// `fun (x : A) (y : B) => e`.
   Fun { binders: Vec<BinderGroup>, body: Box<Term>, span: Span },
   /// Dependent function type `(x : A) (y : B) → C`.
-  Pi { binders: Vec<BinderGroup>, body: Box<Term>, span: Span },
+  Pi {
+    binders: Vec<BinderGroup>,
+    result: ValueContract,
+    body: Box<Term>,
+    span: Span,
+  },
   /// Non-dependent function type `A → B`.
-  Arrow { dom: Box<Term>, cod: Box<Term>, span: Span },
+  Arrow { result: ValueContract, dom: Box<Term>, cod: Box<Term>, span: Span },
   /// `let x : T := v; b` (`non_dep = false`) or
   /// `have x : T := v; b` (`non_dep = true`) — address-relevant.
   Let {
-    non_dep: bool,
+    contract: LetContract,
     name: BinderName,
     ty: Box<Term>,
     val: Box<Term>,
diff --git a/crates/ixon/src/syntax/mod.rs b/crates/ixon/src/syntax/mod.rs
index d40c55772..315252405 100644
--- a/crates/ixon/src/syntax/mod.rs
+++ b/crates/ixon/src/syntax/mod.rs
@@ -26,11 +26,9 @@ pub use error::{Cap, ErrorKind, SyntaxError};
 pub use parse::{parse_file, parse_term};
 pub use print::{print_decl, print_file, print_term};
 
-/// Grammar version this implementation speaks (R7). The `ixon <n>`
-/// header is optional: absent means version 1, forever; grammar
-/// versions ≥ 2 must declare themselves, and canonical version-1
-/// output omits the header.
-pub const VERSION: u64 = 1;
+/// Current grammar version. Whole files require an explicit `ixon 3`
+/// header; standalone terms use the current grammar directly.
+pub const VERSION: u64 = 3;
 
 /// Parser resource caps (R2: gas for admission — parse cost is
 /// chargeable up front). Defaults are deliberately generous for
@@ -90,6 +88,57 @@ mod tests {
     p1
   }
 
+  #[test]
+  fn all_contracts_match_shared_text_fixtures() {
+    let mut count = 0;
+    for line in
+      include_str!("../../../../Tests/Fixtures/ixon-v3/text.tsv").lines()
+    {
+      let columns: Vec<_> = line.split('\t').collect();
+      assert_eq!(columns.len(), 4);
+      let input: u8 = columns[1].parse().unwrap();
+      let output: u64 = columns[2].parse().unwrap();
+      let source = columns[3];
+      let term = parse_term(source, &lims()).unwrap();
+      let key = match &term {
+        Term::Fun { binders, .. } => ("lam", binders[0].contract.to_bits(), 0),
+        Term::Pi { binders, result, .. } => {
+          ("all", binders[0].contract.to_bits(), u64::from(result.to_bits()))
+        },
+        Term::Arrow { result, .. } => ("arrow", 7, u64::from(result.to_bits())),
+        Term::Let { contract, .. } => {
+          ("let", contract.binder.to_bits(), contract.flags())
+        },
+        other => panic!("unexpected fixture AST: {other:?}"),
+      };
+      assert_eq!(key, (columns[0], input, output), "{source}");
+      assert_eq!(roundtrip_term(source).replace('\n', " "), source);
+      count += 1;
+    }
+    assert_eq!(count, 148);
+    for source in [
+      "fun (!! x : A) => x",
+      "fun (~~ x : A) => x",
+      "fun (01 x : A) => x",
+      "fun (&1 x : A) => x",
+      "fun (~!x : A) => x",
+      "A → !! B",
+      "A → ~~ B",
+      "let borrow (~ x y : A) := z; x",
+      "let (!1 x y : A) := z; x",
+    ] {
+      assert!(parse_term(source, &lims()).is_err(), "{source}");
+    }
+  }
+
+  #[test]
+  fn numeric_unnamed_instance_types_preserve_usage() {
+    for ty in ["0", "1", "10", "101 0", "1 → Prop"] {
+      let source = format!("fun [({ty})] => Prop");
+      assert_eq!(roundtrip_term(&source), source);
+    }
+  }
+
   #[test]
   fn term_roundtrips() {
     for src in [
@@ -166,24 +215,36 @@ mod tests {
   fn let_vs_have_is_address_relevant() {
     let l = parse_term("let x : N := v; x", &lims()).unwrap();
     let h = parse_term("have x : N := v; x", &lims()).unwrap();
-    assert!(matches!(l, Term::Let { non_dep: false, .. }));
-    assert!(matches!(h, Term::Let { non_dep: true, .. }));
+    assert!(matches!(
+      l,
+      Term::Let {
+        contract: crate::contract::LetContract { non_dep: false, .. },
+        ..
+      }
+    ));
+    assert!(matches!(
+      h,
+      Term::Let {
+        contract: crate::contract::LetContract { non_dep: true, .. },
+        ..
+      }
+    ));
   }
 
   #[test]
   fn acceptance_fixture_file() {
     // Hand-formatted input…
     let src = "\
-ixon 1
+ixon 3
 import #9c41aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9c41
 
 def : String → Except PatchError String :=
   fun (s : String) => Except.ok PatchError String s
 ";
-    // …normalizes to the canonical form (no version header — absent
-    // means version 1; the def fits in WIDTH columns, so it stays
-    // flat).
+    // The canonical file includes its grammar version.
     let canonical = "\
+ixon 3
+
 import #9c41aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa9c41
 
 def : String → Except PatchError String := \
@@ -195,7 +256,7 @@ fun (s : String) => Except.ok PatchError String s
 
   #[test]
   fn kitchen_sink_file() {
-    let src = r#"ixon 1
+    let src = r#"ixon 3
 
 import #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
 import Std.V2#bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb
@@ -239,58 +300,38 @@ cprj Nat'.succ := #dddd 0 1
 
   #[test]
   fn main_expression() {
-    // Minimal main-only file is already canonical (no header).
-    assert_eq!(roundtrip_file("⊢ 1 : Nat\n"), "⊢ 1 : Nat\n");
-    // An explicit `ixon 1` header is accepted and canonically omitted.
-    assert_eq!(roundtrip_file("ixon 1\n⊢ 1 : Nat\n"), "⊢ 1 : Nat\n");
-    // The ASCII turnstile normalizes to `⊢`.
-    assert_eq!(roundtrip_file("|- 1 : Nat\n"), "⊢ 1 : Nat\n");
-    // Low-precedence values parenthesize canonically (both spellings
-    // reparse identically) — shared golden with the Lean suite.
-    assert_eq!(
-      roundtrip_file("⊢ fun (x : Nat) => x : Nat → Nat\n"),
-      "⊢ (fun (x : Nat) => x) : Nat → Nat\n"
-    );
-    // The annotation is mandatory.
-    let e = parse_file("⊢ 1\n", &lims()).unwrap_err();
-    assert!(matches!(e.kind, ErrorKind::UnexpectedToken { .. }));
-    // Bare form (no turnstile) is accepted as the file's SOLE item —
-    // the door wire, now ceremony-free — and normalizes to `⊢`.
-    assert_eq!(roundtrip_file("1 : Nat\n"), "⊢ 1 : Nat\n");
-    assert_eq!(
-      roundtrip_file(
-        "import \
-         #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\
-         fun (x : Nat) => x : Nat → Nat\n"
+    let cases = [
+      ("⊢ 1 : Nat\n", "⊢ 1 : Nat\n"),
+      ("|- 1 : Nat\n", "⊢ 1 : Nat\n"),
+      ("1 : Nat\n", "⊢ 1 : Nat\n"),
+      (
+        "⊢ fun (x : Nat) => x : Nat → Nat\n",
+        "⊢ (fun (x : Nat) => x) : Nat → Nat\n",
       ),
-      "import \
-       #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\n\
-       ⊢ (fun (x : Nat) => x) : Nat → Nat\n"
-    );
-    // Leading `ixon` NOT followed by a numeral is content, not a
-    // header (a constant may be named `ixon`).
-    assert_eq!(roundtrip_file("ixon : Nat\n"), "⊢ ixon : Nat\n");
-    // The fully minimal wire: no header, no imports (resolution uses
-    // the application's default env), no turnstile — one judgment.
-    assert_eq!(
-      roundtrip_file(
-        "fun (s : String) => Except.ok PatchError String s : \
-         String -> Except PatchError String\n"
+      ("ixon : Nat\n", "⊢ ixon : Nat\n"),
+      (
+        "fun (s : String) => Except.ok PatchError String s : String -> Except PatchError String\n",
+        "⊢ (fun (s : String) => Except.ok PatchError String s) : String → Except PatchError String\n",
       ),
-      "⊢ (fun (s : String) => Except.ok PatchError String s) : \
-       String → Except PatchError String\n"
-    );
-    // After a declaration the turnstile is required: the bare form
-    // errors (the decl's value absorbs the atom, orphaning the `:`) —
-    // never a silent re-split.
-    let e =
-      parse_file("ixon 1\ndef x : N := v\n1 : Nat\n", &lims()).unwrap_err();
-    assert!(matches!(e.kind, ErrorKind::UnexpectedToken { .. }));
-    // At most one, and it must be last.
-    let e = parse_file("⊢ 1 : Nat ⊢ 2 : Nat\n", &lims()).unwrap_err();
-    assert!(matches!(e.kind, ErrorKind::MainExprNotLast));
-    let e = parse_file("⊢ 1 : Nat def x : A := b\n", &lims()).unwrap_err();
-    assert!(matches!(e.kind, ErrorKind::MainExprNotLast));
+      (
+        "import #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\nfun (x : Nat) => x : Nat → Nat\n",
+        "import #aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n\n⊢ (fun (x : Nat) => x) : Nat → Nat\n",
+      ),
+    ];
+    for (src, expected) in cases {
+      assert_eq!(
+        roundtrip_file(&format!("ixon 3\n{src}")),
+        format!("ixon 3\n\n{expected}")
+      );
+    }
+    for src in ["⊢ 1\n", "def x : N := v\n1 : Nat\n"] {
+      let e = parse_file(&format!("ixon 3\n{src}"), &lims()).unwrap_err();
+      assert!(matches!(e.kind, ErrorKind::UnexpectedToken { .. }));
+    }
+    for src in ["⊢ 1 : Nat ⊢ 2 : Nat\n", "⊢ 1 : Nat def x : A := b\n"] {
+      let e = parse_file(&format!("ixon 3\n{src}"), &lims()).unwrap_err();
+      assert!(matches!(e.kind, ErrorKind::MainExprNotLast));
+    }
   }
 
   #[test]
@@ -299,7 +340,7 @@ cprj Nat'.succ := #dddd 0 1
     // preceding declaration's application spine — without it, `⊢ Prop`
     // would be absorbed as an argument of the inductive's type.
     let printed = roundtrip_file(
-      "ixon 1\ninductive N (params := 0) (indices := 0) : Prop\n\n⊢ Prop : Prop\n",
+      "ixon 3\ninductive N (params := 0) (indices := 0) : Prop\n\n⊢ Prop : Prop\n",
     );
     let f = parse_file(&printed, &lims()).unwrap();
     assert_eq!(f.decls.len(), 1);
@@ -307,23 +348,26 @@ cprj Nat'.succ := #dddd 0 1
     // Same shape after a where-block: `|` in ctor loops must not eat
     // the `|-` spelling.
     roundtrip_file(
-      "ixon 1\ninductive N (params := 0) (indices := 0) : Prop where\n  \
+      "ixon 3\ninductive N (params := 0) (indices := 0) : Prop where\n  \
        | c (params := 0) (fields := 0) : N\n|- c : N\n",
     );
   }
 
   #[test]
   fn version_gate() {
-    let e = parse_file("ixon 2\n", &lims()).unwrap_err();
-    assert!(matches!(
-      e.kind,
-      ErrorKind::UnknownVersion { found: 2, supported: 1 }
-    ));
+    for version in [1, 2, 4] {
+      let e = parse_file(&format!("ixon {version}\n"), &lims()).unwrap_err();
+      assert!(
+        matches!(e.kind, ErrorKind::UnknownVersion { found, supported: 3 } if found == version)
+      );
+    }
+    assert!(parse_file("⊢ 1 : Nat\n", &lims()).is_err());
+    assert!(parse_file("ixon 3\n", &lims()).is_ok());
   }
 
   #[test]
   fn import_hash_must_be_full() {
-    let e = parse_file("ixon 1\nimport #abcd\n", &lims()).unwrap_err();
+    let e = parse_file("ixon 3\nimport #abcd\n", &lims()).unwrap_err();
     assert!(matches!(e.kind, ErrorKind::ImportHashLength { found: 4 }));
   }
 
@@ -356,7 +400,7 @@ cprj Nat'.succ := #dddd 0 1
     assert!(matches!(e.kind, ErrorKind::EmptyLevels));
 
     // Line/col are 1-based and positioned.
-    let e = parse_file("ixon 1\ndef x : Nat :=\n", &lims()).unwrap_err();
+    let e = parse_file("ixon 3\ndef x : Nat :=\n", &lims()).unwrap_err();
     assert_eq!(e.line, 3);
   }
 
diff --git a/crates/ixon/src/syntax/parse.rs b/crates/ixon/src/syntax/parse.rs
index 67873bf4e..b931dee9a 100644
--- a/crates/ixon/src/syntax/parse.rs
+++ b/crates/ixon/src/syntax/parse.rs
@@ -20,6 +20,8 @@ use ix_common::env::{BinderInfo, NameComponent};
 use nom::{Err as NErr, IResult};
 use num_bigint::BigUint;
 
+use crate::contract::{BinderContract, LetContract, LetKind, Locality};
+use crate::expr::{Owned, Uses};
 use crate::syntax::Limits;
 use crate::syntax::VERSION;
 use crate::syntax::ast::{
@@ -50,6 +52,7 @@ pub const RESERVED: &[&str] = &[
   "fun",
   "let",
   "have",
+  "borrow",
   "where",
   "proj",
   "Prop",
@@ -885,6 +888,55 @@ impl<'a> P<'a> {
     self.fail(i, "binder name")
   }
 
+  /// Independent compact prefixes; a repeated axis is an error.
+  fn contract_prefix(
+    &self,
+    i: &'a str,
+    allow_usage: bool,
+  ) -> R<'a, BinderContract> {
+    let mut rest = self.ws(i)?;
+    let start = rest;
+    let mut contract = BinderContract::default();
+    let mut usage = false;
+    let mut unique = false;
+    let mut local = false;
+    loop {
+      match rest.as_bytes().first().copied() {
+        Some(b'!') => {
+          if unique {
+            return self.fail(rest, "one ownership prefix");
+          }
+          unique = true;
+          contract.value.owned = Owned::Unique;
+        },
+        Some(b'~') => {
+          if local {
+            return self.fail(rest, "one locality prefix");
+          }
+          local = true;
+          contract.value.locality = Locality::Local;
+        },
+        Some(b'0' | b'1' | b'&') if allow_usage => {
+          if usage {
+            return self.fail(rest, "one usage prefix");
+          }
+          usage = true;
+          contract.uses = match rest.as_bytes()[0] {
+            b'0' => Uses::Erased,
+            b'1' => Uses::Linear,
+            _ => Uses::Affine,
+          };
+        },
+        _ => break,
+      }
+      rest = &rest[1..];
+    }
+    if rest.len() != start.len() && self.ws(rest)?.len() == rest.len() {
+      return self.fail(rest, "space after contract prefix");
+    }
+    Ok((rest, contract))
+  }
+
   /// One bracketed binder group. `(…)` is a *tentative* parse (a
   /// backtrackable failure before the `:` lets callers re-read it as a
   /// parenthesized term); `{…}`, `[…]`, `⦃…⦄` commit immediately —
@@ -904,7 +956,7 @@ impl<'a> P<'a> {
       } else {
         return self.fail(i, "binder");
       };
-    let r = &i[open.len_utf8()..];
+    let (r, contract) = self.contract_prefix(&i[open.len_utf8()..], true)?;
     if open == '[' {
       // `[inst : T]` or unnamed `[T]`.
       if let Ok((r2, names)) = self.binder_names_colon(r) {
@@ -912,14 +964,20 @@ impl<'a> P<'a> {
         let (r4, _) = cut(self.sym(r3, close))?;
         return Ok((
           r4,
-          BinderGroup { info, names, ty, span: self.sp(start, r4) },
+          BinderGroup { contract, info, names, ty, span: self.sp(start, r4) },
         ));
       }
       let (r2, ty) = cut(self.term(r))?;
       let (r3, _) = cut(self.sym(r2, close))?;
       return Ok((
         r3,
-        BinderGroup { info, names: vec![], ty, span: self.sp(start, r3) },
+        BinderGroup {
+          contract,
+          info,
+          names: vec![],
+          ty,
+          span: self.sp(start, r3),
+        },
       ));
     }
     let names_colon = self.binder_names_colon(r);
@@ -930,7 +988,10 @@ impl<'a> P<'a> {
     };
     let (r3, ty) = cut(self.term(r2))?;
     let (r4, _) = cut(self.sym(r3, close))?;
-    Ok((r4, BinderGroup { info, names, ty, span: self.sp(start, r4) }))
+    Ok((
+      r4,
+      BinderGroup { contract, info, names, ty, span: self.sp(start, r4) },
+    ))
   }
 
   /// `ident+ :` — the committing prefix of a named binder group.
@@ -981,9 +1042,25 @@ impl<'a> P<'a> {
   fn let_term(&self, i: &'a str, non_dep: bool) -> R<'a, Term> {
     let word = if non_dep { "have" } else { "let" };
     let (r, ksp) = self.kw(i, word)?;
-    let (r, name) = cut(self.binder_name(r))?;
-    let (r, _) = cut(self.sym(r, ":"))?;
-    let (r, ty) = cut(self.term(r))?;
+    let (r, kind) = if self.peek_word(r)?.1 == Some("borrow") {
+      let (r, _) = self.kw(r, "borrow")?;
+      (r, LetKind::BorrowShared)
+    } else {
+      (r, LetKind::Value)
+    };
+    let r = self.ws(r)?;
+    let (r, (name, ty, binder)) = if r.starts_with('(') {
+      let (r, group) = cut(self.binder_group(r))?;
+      if group.info != BinderInfo::Default || group.names.len() != 1 {
+        return cut(self.fail(r, "one explicit let binder"));
+      }
+      (r, (group.names.into_iter().next().unwrap(), group.ty, group.contract))
+    } else {
+      let (r, name) = cut(self.binder_name(r))?;
+      let (r, _) = cut(self.sym(r, ":"))?;
+      let (r, ty) = cut(self.term(r))?;
+      (r, (name, ty, BinderContract::default()))
+    };
     let (r, _) = cut(self.sym(r, ":="))?;
     let (r, val) = cut(self.term(r))?;
     let (r, _) = cut(self.sym(r, ";"))?;
@@ -992,7 +1069,7 @@ impl<'a> P<'a> {
     Ok((
       r,
       Term::Let {
-        non_dep,
+        contract: LetContract { non_dep, kind, binder },
         name,
         ty: Box::new(ty),
         val: Box::new(val),
@@ -1021,9 +1098,18 @@ impl<'a> P<'a> {
       }
     }
     let (r, _) = cut(self.arrow_tok(rest))?;
+    let (r, output) = cut(self.contract_prefix(r, false))?;
     let (r, body) = cut(self.term(r))?;
     let span = self.sp(start, start).to(body.span());
-    Ok((r, Term::Pi { binders: groups, body: Box::new(body), span }))
+    Ok((
+      r,
+      Term::Pi {
+        binders: groups,
+        result: output.value,
+        body: Box::new(body),
+        span,
+      },
+    ))
   }
 
   /// Arrow layer: dependent domain, or application with optional `→`.
@@ -1043,9 +1129,18 @@ impl<'a> P<'a> {
     let (r, lhs) = self.app(j)?;
     match self.arrow_tok(r) {
       Ok((r2, _)) => {
+        let (r2, output) = cut(self.contract_prefix(r2, false))?;
         let (r3, cod) = cut(self.term(r2))?;
         let span = lhs.span().to(cod.span());
-        Ok((r3, Term::Arrow { dom: Box::new(lhs), cod: Box::new(cod), span }))
+        Ok((
+          r3,
+          Term::Arrow {
+            result: output.value,
+            dom: Box::new(lhs),
+            cod: Box::new(cod),
+            span,
+          },
+        ))
       },
       Err(NErr::Failure(e)) => Err(NErr::Failure(e)),
       Err(_) => Ok((r, lhs)),
@@ -1528,32 +1623,14 @@ impl<'a> P<'a> {
   /// optional main expression, EOF.
   fn file(&self, i: &'a str) -> R<'a, File> {
     let start = self.ws(i)?;
-    // Optional version header: absent means version 1, forever
-    // (grammar versions ≥ 2 must declare themselves). A leading
-    // `ixon` followed by a numeral is always the header (a constant
-    // literally named `ixon` applied to a literal at file start needs
-    // parens); followed by anything else it is content.
-    let (r, version) = {
-      let (_, word) = self.peek_word(start)?;
-      if word == Some("ixon") {
-        let (after, _) = self.kw(start, "ixon")?;
-        let j = self.ws(after)?;
-        if j.starts_with(|c: char| c.is_ascii_digit()) {
-          let (r, (version, vsp)) = self.nat_u64(after)?;
-          if version != VERSION {
-            return self.fatal(
-              ErrorKind::UnknownVersion { found: version, supported: VERSION },
-              vsp,
-            );
-          }
-          (r, version)
-        } else {
-          (start, VERSION)
-        }
-      } else {
-        (start, VERSION)
-      }
-    };
+    let (r, _) = cut(self.kw(start, "ixon"))?;
+    let (r, (version, vsp)) = cut(self.nat_u64(r))?;
+    if version != VERSION {
+      return self.fatal(
+        ErrorKind::UnknownVersion { found: version, supported: VERSION },
+        vsp,
+      );
+    }
     let mut imports = Vec::new();
     let mut rest = r;
     loop {
diff --git a/crates/ixon/src/syntax/print.rs b/crates/ixon/src/syntax/print.rs
index 9bb4a3f8b..b6108bd21 100644
--- a/crates/ixon/src/syntax/print.rs
+++ b/crates/ixon/src/syntax/print.rs
@@ -8,6 +8,8 @@
 //! pinned `Name#hash` references are laid out — exists to reparse to
 //! the same tree.
 
+use crate::contract::{BinderContract, LetKind, Locality, ValueContract};
+use crate::expr::{Owned, Uses};
 use ix_common::env::{BinderInfo, NameComponent};
 
 use crate::syntax::ast::{
@@ -302,27 +304,37 @@ fn term_doc_bare(t: &Term) -> Doc {
       ds.push(group(nest(cat(vec![line(), term_doc(body, 0)]))));
       cat(ds)
     },
-    Term::Pi { binders, body, .. } => {
+    Term::Pi { binders, result, body, .. } => {
       let mut ds = Vec::new();
       for b in binders {
         ds.push(binder_doc(b));
         ds.push(text(" "));
       }
       ds.push(text("→"));
-      ds.push(group(nest(cat(vec![line(), term_doc(body, 1)]))));
+      ds.push(group(nest(cat(vec![line(), result_doc(*result, body)]))));
       cat(ds)
     },
-    Term::Arrow { dom, cod, .. } => cat(vec![
+    Term::Arrow { result, dom, cod, .. } => cat(vec![
       term_doc(dom, 2),
       text(" →"),
-      group(nest(cat(vec![line(), term_doc(cod, 1)]))),
+      group(nest(cat(vec![line(), result_doc(*result, cod)]))),
     ]),
-    Term::Let { non_dep, name, ty, val, body, .. } => {
-      let kw = if *non_dep { "have" } else { "let" };
+    Term::Let { contract, name, ty, val, body, .. } => {
+      let kw = if contract.non_dep { "have" } else { "let" };
+      let borrow =
+        if contract.kind == LetKind::BorrowShared { " borrow" } else { "" };
+      let annotated = contract.kind != LetKind::Value
+        || contract.binder != BinderContract::default();
+      let open = if annotated { "(" } else { "" };
+      let close = if annotated { ")" } else { "" };
       cat(vec![
-        text(format!("{kw} {} : ", binder_name_str(name))),
+        text(format!(
+          "{kw}{borrow} {open}{}{} : ",
+          binder_prefix(contract.binder),
+          binder_name_str(name)
+        )),
         term_doc(ty, 0),
-        text(" :="),
+        text(format!("{close} :=")),
         group(nest(cat(vec![line(), term_doc(val, 0)]))),
         text(";"),
         hard(),
@@ -336,6 +348,40 @@ fn term_doc_bare(t: &Term) -> Doc {
   }
 }
 
+fn value_prefix(value: ValueContract) -> String {
+  let mut prefix = String::new();
+  if value.locality == Locality::Local {
+    prefix.push('~');
+  }
+  if value.owned == Owned::Unique {
+    prefix.push('!');
+  }
+  prefix
+}
+
+fn binder_prefix(contract: BinderContract) -> String {
+  let mut prefix = value_prefix(contract.value);
+  match contract.uses {
+    Uses::Erased => prefix.push('0'),
+    Uses::Linear => prefix.push('1'),
+    Uses::Affine => prefix.push('&'),
+    Uses::Many => {},
+  }
+  if !prefix.is_empty() {
+    prefix.push(' ');
+  }
+  prefix
+}
+
+fn result_doc(result: ValueContract, term: &Term) -> Doc {
+  let prefix = value_prefix(result);
+  if prefix.is_empty() {
+    term_doc(term, 1)
+  } else {
+    cat(vec![text(format!("{prefix} ")), term_doc(term, 1)])
+  }
+}
+
 fn binder_name_str(b: &BinderName) -> String {
   match b {
     BinderName::Ident(c, _) => component_str(c),
@@ -343,6 +389,16 @@ fn binder_name_str(b: &BinderName) -> String {
   }
 }
 
+// Numerals at the start of an unnamed instance type overlap usage prefixes.
+fn numeric_head(term: &Term) -> bool {
+  match term {
+    Term::NatLit(..) => true,
+    Term::App { head, .. } => numeric_head(head),
+    Term::Arrow { dom, .. } => numeric_head(dom),
+    _ => false,
+  }
+}
+
 fn binder_doc(b: &BinderGroup) -> Doc {
   let (open, close) = match b.info {
     BinderInfo::Default => ("(", ")"),
@@ -350,10 +406,15 @@ fn binder_doc(b: &BinderGroup) -> Doc {
     BinderInfo::StrictImplicit => ("⦃", "⦄"),
     BinderInfo::InstImplicit => ("[", "]"),
   };
-  let mut ds = vec![text(open)];
+  let mut ds = vec![text(open), text(binder_prefix(b.contract))];
   if b.names.is_empty() {
-    // Unnamed instance binder `[T]`.
-    ds.push(term_doc(&b.ty, 0));
+    // Keep a numeric type distinct from a usage prefix, e.g. `[(1)]`.
+    let ty = term_doc(&b.ty, 0);
+    if b.contract == BinderContract::default() && numeric_head(&b.ty) {
+      ds.push(cat(vec![text("("), ty, text(")")]));
+    } else {
+      ds.push(ty);
+    }
   } else {
     let names: Vec<String> = b.names.iter().map(binder_name_str).collect();
     ds.push(text(format!("{} : ", names.join(" "))));
@@ -533,16 +594,13 @@ pub fn print_decl(d: &Decl) -> String {
 
 /// Print a whole file in canonical form: sections (imports block,
 /// declarations, optional trailing main expression) separated by
-/// blank lines, trailing newline. The version header is emitted only
-/// for versions ≥ 2 — absent means version 1, forever. The main
+/// blank lines, trailing newline. The version header is always emitted. The main
 /// expression's value prints at precedence 2 — `fun`/`let`/arrows
 /// parenthesize, so `⊢ (fun (x : A) => x) : A → A` rather than the
 /// visually ambiguous bare form (both reparse identically).
 pub fn print_file(f: &File) -> String {
   let mut sections: Vec<String> = Vec::new();
-  if f.version != 1 {
-    sections.push(format!("ixon {}", f.version));
-  }
+  sections.push(format!("ixon {}", f.version));
   if !f.imports.is_empty() {
     sections
       .push(f.imports.iter().map(import_str).collect::<Vec<_>>().join("\n"));
diff --git a/crates/ixon/src/syntax/props.rs b/crates/ixon/src/syntax/props.rs
index ea3c9e302..3b6df4ded 100644
--- a/crates/ixon/src/syntax/props.rs
+++ b/crates/ixon/src/syntax/props.rs
@@ -20,6 +20,7 @@
 // expr.rs / constant.rs).
 #![allow(clippy::needless_pass_by_value)]
 
+use crate::contract::{BinderContract, LetContract, LetKind, ValueContract};
 use bignat::Nat;
 use ix_common::env::{BinderInfo, NameComponent};
 use num_bigint::BigUint;
@@ -162,7 +163,14 @@ fn arb_binder(g: &mut Gen, depth: usize) -> BinderGroup {
   } else {
     (0..1 + pick(g, 2)).map(|_| arb_binder_name(g)).collect()
   };
-  BinderGroup { info, names, ty: arb_term(g, depth), span: Span::default() }
+  BinderGroup {
+    contract: BinderContract::from_bits(u8::try_from(pick(g, 16)).unwrap())
+      .unwrap(),
+    info,
+    names,
+    ty: arb_term(g, depth),
+    span: Span::default(),
+  }
 }
 
 fn arb_sort(g: &mut Gen) -> SortKind {
@@ -198,17 +206,30 @@ fn arb_term(g: &mut Gen, depth: usize) -> Term {
       span: sp,
     },
     5 => Term::Pi {
+      result: ValueContract::from_bits(u8::try_from(pick(g, 4)).unwrap())
+        .unwrap(),
       binders: (0..1 + pick(g, 2)).map(|_| arb_binder(g, d)).collect(),
       body: Box::new(arb_term(g, d)),
       span: sp,
     },
     6 => Term::Arrow {
+      result: ValueContract::from_bits(u8::try_from(pick(g, 4)).unwrap())
+        .unwrap(),
       dom: Box::new(arb_term(g, d)),
       cod: Box::new(arb_term(g, d)),
       span: sp,
     },
     7 => Term::Let {
-      non_dep: bool::arbitrary(g),
+      contract: LetContract {
+        non_dep: bool::arbitrary(g),
+        kind: if bool::arbitrary(g) {
+          LetKind::Value
+        } else {
+          LetKind::BorrowShared
+        },
+        binder: BinderContract::from_bits(u8::try_from(pick(g, 16)).unwrap())
+          .unwrap(),
+      },
       name: arb_binder_name(g),
       ty: Box::new(arb_term(g, d)),
       val: Box::new(arb_term(g, d)),
diff --git a/crates/ixon/src/tag.rs b/crates/ixon/src/tag.rs
index 35465aaab..a303d5d08 100644
--- a/crates/ixon/src/tag.rs
+++ b/crates/ixon/src/tag.rs
@@ -94,6 +94,9 @@ impl Tag4 {
     } else {
       u64::from(small)
     };
+    if large && (size < 8 || u64_byte_count(size) != small + 1) {
+      return Err("Tag4::get: noncanonical integer".into());
+    }
     Ok(Tag4 { flag, size })
   }
 
@@ -154,6 +157,9 @@ impl Tag2 {
     } else {
       u64::from(small)
     };
+    if large && (size < 32 || u64_byte_count(size) != small + 1) {
+      return Err("Tag2::get: noncanonical integer".into());
+    }
     Ok(Tag2 { flag, size })
   }
 
@@ -212,6 +218,9 @@ impl Tag0 {
     } else {
       u64::from(small)
     };
+    if large && (size < 128 || u64_byte_count(size) != small + 1) {
+      return Err("Tag0::get: noncanonical integer".into());
+    }
     Ok(Tag0 { size })
   }
 
diff --git a/crates/ixvm-codegen/src/aiur_ix_aggr.rs b/crates/ixvm-codegen/src/aiur_ix_aggr.rs
index ec429aea3..0b534f731 100644
--- a/crates/ixvm-codegen/src/aiur_ix_aggr.rs
+++ b/crates/ixvm-codegen/src/aiur_ix_aggr.rs
@@ -21954,29 +21954,43 @@ fn aiur_fn_231(
     if (__v_1 != __v_3) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("aggr: claim is not CheckEnv".to_string()) });
     }
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__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 __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = G::from_u64(1);
-    if (__v_9 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) });
+    let __v_6: G = G::from_u64(3);
+    if (__v_4 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("aggr: unsupported object format".to_string()) });
+    }
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__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);
+    if (__v_7 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("aggr: wrong validator identity".to_string()) });
+    }
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_15: G = __loaded[0];
+    let __v_16: G = __loaded[1];
+    let __v_17: G = __loaded[2];
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(1);
+    if (__v_15 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) });
     }
-    if (__v_10 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) });
+    if (__v_16 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) });
     }
-    if (__v_11 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) });
+    if (__v_17 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("aggr: trailing bytes after CheckEnv claim".to_string()) });
     }
-    let __ret: [G; OUT_231] = [__v_4, __v_6, __v_7];
+    let __ret: [G; OUT_231] = [__v_10, __v_12, __v_13];
     record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
diff --git a/crates/ixvm-codegen/src/aiur_ixvm.rs b/crates/ixvm-codegen/src/aiur_ixvm.rs
index cba85c86f..2e22b613d 100644
--- a/crates/ixvm-codegen/src/aiur_ixvm.rs
+++ b/crates/ixvm-codegen/src/aiur_ixvm.rs
@@ -5229,7 +5229,7 @@ fn aiur_fn_29(
     let __v_72: G = __r_arr[63];
     match __v_2.as_canonical_u64() {
       1023u64 => {
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[788].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[788].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { *(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788]) }; __ret }, _ => aiur_fn_788(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_74: G = __loaded[0];
@@ -5410,10 +5410,10 @@ fn aiur_fn_29(
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[788].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[788].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { *(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788]) }; __ret }, _ => aiur_fn_788(__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_783] = { let __args: [G; IN_783] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[788].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[788].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { *(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788]) }; __ret }, _ => aiur_fn_788(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr };
         let __v_76: G = __loaded[0];
@@ -7948,7 +7948,7 @@ fn aiur_fn_34(
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -7969,7 +7969,7 @@ fn aiur_fn_34(
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __v_21: G = __r_arr[2];
@@ -8037,7 +8037,7 @@ fn aiur_fn_34(
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__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];
@@ -8047,7 +8047,7 @@ fn aiur_fn_34(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(7);
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
@@ -8056,7 +8056,7 @@ fn aiur_fn_34(
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__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];
@@ -8066,7 +8066,7 @@ fn aiur_fn_34(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(8);
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
@@ -8075,7 +8075,7 @@ fn aiur_fn_34(
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__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];
@@ -8085,7 +8085,7 @@ fn aiur_fn_34(
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
         let __v_27: G = G::from_u64(9);
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_27, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
@@ -8094,75 +8094,106 @@ fn aiur_fn_34(
         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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_19: G = __loaded[0];
-        let __v_20: G = __loaded[1];
-        let __v_21: G = __loaded[2];
-        let __v_22: G = __loaded[3];
-        let __v_23: G = __loaded[4];
-        let __v_24: G = __loaded[5];
-        let __v_25: G = __loaded[6];
-        let __v_26: G = __loaded[7];
-        let __v_27: G = __loaded[8];
-        let __v_28: G = __loaded[9];
-        let __v_29: G = __loaded[10];
-        let __v_30: G = __loaded[11];
-        let __v_31: G = __loaded[12];
-        let __v_32: G = __loaded[13];
-        let __v_33: G = __loaded[14];
-        let __v_34: G = __loaded[15];
-        let __v_35: G = __loaded[16];
-        let __v_36: G = __loaded[17];
-        let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
-        let __v_37: G = __loaded[0];
-        let __v_38: G = __loaded[1];
-        let __v_39: G = __loaded[2];
-        let __v_40: G = __loaded[3];
-        let __v_41: G = __loaded[4];
-        let __v_42: G = __loaded[5];
-        let __v_43: G = __loaded[6];
-        let __v_44: G = __loaded[7];
-        let __v_45: G = __loaded[8];
-        let __v_46: G = __loaded[9];
-        let __v_47: G = __loaded[10];
-        let __v_48: G = __loaded[11];
-        let __v_49: G = __loaded[12];
-        let __v_50: G = __loaded[13];
-        let __v_51: G = __loaded[14];
-        let __v_52: G = __loaded[15];
-        let __v_53: G = __loaded[16];
-        let __v_54: G = __loaded[17];
-        let __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
-        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 __v_67: G = __loaded[12];
-        let __v_68: G = __loaded[13];
-        let __v_69: G = __loaded[14];
-        let __v_70: G = __loaded[15];
-        let __v_71: G = __loaded[16];
-        let __v_72: G = __loaded[17];
-        let __v_73: G = G::from_u64(10);
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
-        let __v_74: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
-        let __v_75: G = __r_arr[0];
-        let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
-        let __v_76: G = __r_arr[0];
-        let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_73, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
-        let __v_77: G = __r_arr[0];
-        let __ret: [G; OUT_34] = [__v_77];
-        record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained);
-        return Ok(__ret);
+        match __v_1.as_canonical_u64() {
+          _ => {
+            let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+            let __v_19: G = __loaded[0];
+            let __v_20: G = __loaded[1];
+            let __v_21: G = __loaded[2];
+            let __v_22: G = __loaded[3];
+            let __v_23: G = __loaded[4];
+            let __v_24: G = __loaded[5];
+            let __v_25: G = __loaded[6];
+            let __v_26: G = __loaded[7];
+            let __v_27: G = __loaded[8];
+            let __v_28: G = __loaded[9];
+            let __v_29: G = __loaded[10];
+            let __v_30: G = __loaded[11];
+            let __v_31: G = __loaded[12];
+            let __v_32: G = __loaded[13];
+            let __v_33: G = __loaded[14];
+            let __v_34: G = __loaded[15];
+            let __v_35: G = __loaded[16];
+            let __v_36: G = __loaded[17];
+            let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
+            let __v_37: G = __loaded[0];
+            let __v_38: G = __loaded[1];
+            let __v_39: G = __loaded[2];
+            let __v_40: G = __loaded[3];
+            let __v_41: G = __loaded[4];
+            let __v_42: G = __loaded[5];
+            let __v_43: G = __loaded[6];
+            let __v_44: G = __loaded[7];
+            let __v_45: G = __loaded[8];
+            let __v_46: G = __loaded[9];
+            let __v_47: G = __loaded[10];
+            let __v_48: G = __loaded[11];
+            let __v_49: G = __loaded[12];
+            let __v_50: G = __loaded[13];
+            let __v_51: G = __loaded[14];
+            let __v_52: G = __loaded[15];
+            let __v_53: G = __loaded[16];
+            let __v_54: G = __loaded[17];
+            let __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
+            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 __v_67: G = __loaded[12];
+            let __v_68: G = __loaded[13];
+            let __v_69: G = __loaded[14];
+            let __v_70: G = __loaded[15];
+            let __v_71: G = __loaded[16];
+            let __v_72: G = __loaded[17];
+            let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
+  0u64 => {
+    let __v_73: G = G::from_u64(0);
+    break '__mc_0 [__v_73];
+  },
+  1u64 => {
+    let __v_73: G = G::from_u64(1);
+    break '__mc_0 [__v_73];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
+  },
+}
+ };
+            let __v_73: G = __mc_out___mc_0[0];
+            let __v_74: G = G::from_u64(2);
+            let __v_75: G = (__v_74 * __v_73);
+            let __v_76: G = (__v_1 + __v_75);
+            let __v_77: G = G::from_u64(0);
+            let __v_78: G = G::from_u64(0);
+            let __v_79: G = G::from_u64(0);
+            let __v_80: G = G::from_u64(0);
+            let __v_81: G = G::from_u64(0);
+            let __v_82: G = G::from_u64(0);
+            let __v_83: G = G::from_u64(0);
+            let __v_84: G = G::from_u64(10);
+            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __v_85: G = __r_arr[0];
+            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_85]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __v_86: G = __r_arr[0];
+            let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
+            let __v_87: G = __r_arr[0];
+            let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_3, __v_4, __v_5, __v_87]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } };
+            let __v_88: G = __r_arr[0];
+            let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_84, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_88]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
+            let __v_89: G = __r_arr[0];
+            let __ret: [G; OUT_34] = [__v_89];
+            record.function_queries[34].finish(&inp[..], &__ret[..], !unconstrained);
+            return Ok(__ret);
+          },
+        }
       },
       11u64 => {
         let __v_19: G = G::from_u64(11);
@@ -8494,41 +8525,44 @@ fn aiur_fn_40(
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
-      0u64 => {
-        let __v_2: G = G::from_u64(0);
-        let __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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];
-        record.function_queries[40].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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];
-        record.function_queries[40].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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];
-        record.function_queries[40].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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];
+      _ => {
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
+  0u64 => {
+    let __v_2: G = G::from_u64(0);
+    break '__mc_0 [__v_2];
+  },
+  1u64 => {
+    let __v_2: G = G::from_u64(1);
+    break '__mc_0 [__v_2];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+  },
+}
+ };
+        let __v_2: G = __mc_out___mc_0[0];
+        let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() {
+  0u64 => {
+    let __v_3: G = G::from_u64(0);
+    break '__mc_1 [__v_3];
+  },
+  1u64 => {
+    let __v_3: G = G::from_u64(1);
+    break '__mc_1 [__v_3];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+  },
+}
+ };
+        let __v_3: G = __mc_out___mc_1[0];
+        let __v_4: G = G::from_u64(2);
+        let __v_5: G = (__v_4 * __v_3);
+        let __v_6: G = (__v_2 + __v_5);
+        let __ret: [G; OUT_40] = [__v_6];
         record.function_queries[40].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
-      },
     }
   })
 }
@@ -8547,114 +8581,107 @@ fn aiur_fn_41(
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
-      0u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(0);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(4);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-          },
-        }
-      },
-      1u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(1);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(5);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-          },
-        }
-      },
-      2u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(2);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(6);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-          },
-        }
-      },
-      3u64 => {
-        match __v_1.as_canonical_u64() {
-          0u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(3);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_3: G = G::from_u64(0);
-            let __v_4: G = G::from_u64(7);
-            let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_41] = [__v_5];
-            record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-          },
-        }
-      },
       _ => {
-        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+        let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
+  0u64 => {
+    let __v_3: G = G::from_u64(0);
+    break '__mc_0 [__v_3];
+  },
+  1u64 => {
+    let __v_3: G = G::from_u64(1);
+    break '__mc_0 [__v_3];
+  },
+  2u64 => {
+    let __v_3: G = G::from_u64(2);
+    break '__mc_0 [__v_3];
+  },
+  3u64 => {
+    let __v_3: G = G::from_u64(3);
+    break '__mc_0 [__v_3];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+  },
+}
+ };
+        let __v_3: G = __mc_out___mc_0[0];
+        let __v_4: G = G::from_u64(4);
+        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__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_3 + __v_6);
+        let __ret: [G; OUT_41] = [__v_7];
+        record.function_queries[41].finish(&inp[..], &__ret[..], !unconstrained);
+        return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_42: usize = 18;
-const IN_42: usize = 18;
-const OUT_42: usize = 8;
+const INPUT_SIZE_42: usize = 4;
+const IN_42: usize = 4;
+const OUT_42: usize = 1;
 fn aiur_fn_42(
   inp: [G; IN_42],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_42], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(0);
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __v_5: G = __r_arr[0];
+    let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_42] = [__v_6];
+    record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_43: usize = 6;
+const IN_43: usize = 6;
+const OUT_43: usize = 1;
+fn aiur_fn_43(
+  inp: [G; IN_43],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_43], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } };
+    let __v_6: G = __r_arr[0];
+    let __v_7: G = G::from_u64(16);
+    let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = (__v_7 * __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = G::from_u64(0);
+    let __v_12: G = { let __values: [G; 3] = [__v_11, __v_10, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_43] = [__v_12];
+    record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_44: usize = 18;
+const IN_44: usize = 18;
+const OUT_44: usize = 8;
+fn aiur_fn_44(
+  inp: [G; IN_44],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_44], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8695,7 +8722,7 @@ fn aiur_fn_42(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__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];
@@ -8713,8 +8740,8 @@ fn aiur_fn_42(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_42] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_44] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -8726,23 +8753,23 @@ fn aiur_fn_42(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_42] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[42].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_43: usize = 18;
-const IN_43: usize = 18;
-const OUT_43: usize = 8;
-fn aiur_fn_43(
-  inp: [G; IN_43],
+const INPUT_SIZE_45: usize = 18;
+const IN_45: usize = 18;
+const OUT_45: usize = 8;
+fn aiur_fn_45(
+  inp: [G; IN_45],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_43], ExecError> {
+) -> Result<[G; OUT_45], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8764,7 +8791,7 @@ fn aiur_fn_43(
     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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
@@ -8783,7 +8810,7 @@ fn aiur_fn_43(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__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];
@@ -8801,8 +8828,8 @@ fn aiur_fn_43(
         let __v_49: G = __r_arr[5];
         let __v_50: G = __r_arr[6];
         let __v_51: G = __r_arr[7];
-        let __ret: [G; OUT_43] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_45] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -8814,23 +8841,23 @@ fn aiur_fn_43(
         let __v_23: G = G::from_u64(0);
         let __v_24: G = G::from_u64(0);
         let __v_25: G = G::from_u64(0);
-        let __ret: [G; OUT_43] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[43].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_45] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_44: usize = 18;
-const IN_44: usize = 18;
-const OUT_44: usize = 8;
-fn aiur_fn_44(
-  inp: [G; IN_44],
+const INPUT_SIZE_46: usize = 18;
+const IN_46: usize = 18;
+const OUT_46: usize = 8;
+fn aiur_fn_46(
+  inp: [G; IN_46],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_44], ExecError> {
+) -> Result<[G; OUT_46], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8852,7 +8879,7 @@ fn aiur_fn_44(
     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_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
@@ -8871,7 +8898,7 @@ fn aiur_fn_44(
         let __v_33: G = __loaded[15];
         let __v_34: G = __loaded[16];
         let __v_35: G = __loaded[17];
-        let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[44].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[44].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[44].bump_multiplicity(__i); } let __ret: [G; OUT_44] = unsafe { *(record.function_queries[44].output_at(__i).as_ptr() as *const [G; OUT_44]) }; __ret }, _ => aiur_fn_44(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__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];
@@ -8889,8 +8916,8 @@ fn aiur_fn_44(
         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_44] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
-        record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_46] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51];
+        record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -8902,23 +8929,23 @@ fn aiur_fn_44(
         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_44] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
-        record.function_queries[44].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_46] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25];
+        record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_45: usize = 19;
-const IN_45: usize = 19;
-const OUT_45: usize = 1;
-fn aiur_fn_45(
-  inp: [G; IN_45],
+const INPUT_SIZE_47: usize = 19;
+const IN_47: usize = 19;
+const OUT_47: usize = 1;
+fn aiur_fn_47(
+  inp: [G; IN_47],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_45], ExecError> {
+) -> Result<[G; OUT_47], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -8981,32 +9008,32 @@ fn aiur_fn_45(
         let __v_54: G = __loaded[17];
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
-        let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[45].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[45].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[45].bump_multiplicity(__i); } let __ret: [G; OUT_45] = unsafe { *(record.function_queries[45].output_at(__i).as_ptr() as *const [G; OUT_45]) }; __ret }, _ => aiur_fn_45(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __ret: [G; OUT_45] = [__v_56];
-        record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_47] = [__v_56];
+        record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_45] = [__v_19];
-        record.function_queries[45].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_47] = [__v_19];
+        record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_46: usize = 19;
-const IN_46: usize = 19;
-const OUT_46: usize = 1;
-fn aiur_fn_46(
-  inp: [G; IN_46],
+const INPUT_SIZE_48: usize = 19;
+const IN_48: usize = 19;
+const OUT_48: usize = 1;
+fn aiur_fn_48(
+  inp: [G; IN_48],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_46], ExecError> {
+) -> Result<[G; OUT_48], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9029,7 +9056,7 @@ fn aiur_fn_46(
     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_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
@@ -9048,7 +9075,7 @@ fn aiur_fn_46(
         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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
@@ -9067,36 +9094,36 @@ fn aiur_fn_46(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[46].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[46].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[46].bump_multiplicity(__i); } let __ret: [G; OUT_46] = unsafe { *(record.function_queries[46].output_at(__i).as_ptr() as *const [G; OUT_46]) }; __ret }, _ => aiur_fn_46(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_1, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_1, __v_2, __v_3, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[42].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[42].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[42].bump_multiplicity(__i); } let __ret: [G; OUT_42] = unsafe { *(record.function_queries[42].output_at(__i).as_ptr() as *const [G; OUT_42]) }; __ret }, _ => aiur_fn_42(__args, record, io_buffer, __cu)? } };
         let __v_57: G = __r_arr[0];
-        let __ret: [G; OUT_46] = [__v_57];
-        record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_48] = [__v_57];
+        record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_46] = [__v_19];
-        record.function_queries[46].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_48] = [__v_19];
+        record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_47: usize = 19;
-const IN_47: usize = 19;
-const OUT_47: usize = 1;
-fn aiur_fn_47(
-  inp: [G; IN_47],
+const INPUT_SIZE_49: usize = 19;
+const IN_49: usize = 19;
+const OUT_49: usize = 1;
+fn aiur_fn_49(
+  inp: [G; IN_49],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_47], ExecError> {
+) -> Result<[G; OUT_49], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9119,7 +9146,7 @@ fn aiur_fn_47(
     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_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
@@ -9138,7 +9165,7 @@ fn aiur_fn_47(
         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_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
@@ -9157,36 +9184,36 @@ fn aiur_fn_47(
         let __v_52: G = __loaded[15];
         let __v_53: G = __loaded[16];
         let __v_54: G = __loaded[17];
-        let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[47].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[47].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[47].bump_multiplicity(__i); } let __ret: [G; OUT_47] = unsafe { *(record.function_queries[47].output_at(__i).as_ptr() as *const [G; OUT_47]) }; __ret }, _ => aiur_fn_47(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
-        let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_1, __v_2, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[41].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[41].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[41].bump_multiplicity(__i); } let __ret: [G; OUT_41] = unsafe { *(record.function_queries[41].output_at(__i).as_ptr() as *const [G; OUT_41]) }; __ret }, _ => aiur_fn_41(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[43].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[43].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[43].bump_multiplicity(__i); } let __ret: [G; OUT_43] = unsafe { *(record.function_queries[43].output_at(__i).as_ptr() as *const [G; OUT_43]) }; __ret }, _ => aiur_fn_43(__args, record, io_buffer, __cu)? } };
         let __v_57: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_57];
-        record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_49] = [__v_57];
+        record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_47] = [__v_19];
-        record.function_queries[47].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_49] = [__v_19];
+        record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_48: usize = 2;
-const IN_48: usize = 2;
-const OUT_48: usize = 1;
-fn aiur_fn_48(
-  inp: [G; IN_48],
+const INPUT_SIZE_50: usize = 2;
+const IN_50: usize = 2;
+const OUT_50: usize = 1;
+fn aiur_fn_50(
+  inp: [G; IN_50],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_48], ExecError> {
+) -> Result<[G; OUT_50], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9287,21 +9314,21 @@ fn aiur_fn_48(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_48] = [__v_97];
-    record.function_queries[48].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_50] = [__v_97];
+    record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_49: usize = 2;
-const IN_49: usize = 2;
-const OUT_49: usize = 1;
-fn aiur_fn_49(
-  inp: [G; IN_49],
+const INPUT_SIZE_51: usize = 2;
+const IN_51: usize = 2;
+const OUT_51: usize = 1;
+fn aiur_fn_51(
+  inp: [G; IN_51],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_49], ExecError> {
+) -> Result<[G; OUT_51], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9310,20 +9337,20 @@ fn aiur_fn_49(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(2);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -9335,20 +9362,20 @@ fn aiur_fn_49(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(4);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(5);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(6);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -9360,20 +9387,20 @@ fn aiur_fn_49(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(8);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_2: G = G::from_u64(9);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_2: G = G::from_u64(10);
-            let __ret: [G; OUT_49] = [__v_2];
-            record.function_queries[49].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_51] = [__v_2];
+            record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -9388,15 +9415,15 @@ fn aiur_fn_49(
   })
 }
 
-const INPUT_SIZE_50: usize = 9;
-const IN_50: usize = 9;
-const OUT_50: usize = 8;
-fn aiur_fn_50(
-  inp: [G; IN_50],
+const INPUT_SIZE_52: usize = 9;
+const IN_52: usize = 9;
+const OUT_52: usize = 8;
+fn aiur_fn_52(
+  inp: [G; IN_52],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_50], ExecError> {
+) -> Result<[G; OUT_52], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9419,7 +9446,7 @@ fn aiur_fn_50(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__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];
@@ -9437,8 +9464,8 @@ fn aiur_fn_50(
         let __v_31: G = __r_arr[5];
         let __v_32: G = __r_arr[6];
         let __v_33: G = __r_arr[7];
-        let __ret: [G; OUT_50] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-        record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_52] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -9450,23 +9477,23 @@ fn aiur_fn_50(
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
-        let __ret: [G; OUT_50] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
-        record.function_queries[50].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_52] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16];
+        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_51: usize = 9;
-const IN_51: usize = 9;
-const OUT_51: usize = 9;
-fn aiur_fn_51(
-  inp: [G; IN_51],
+const INPUT_SIZE_53: usize = 9;
+const IN_53: usize = 9;
+const OUT_53: usize = 9;
+fn aiur_fn_53(
+  inp: [G; IN_53],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_51], ExecError> {
+) -> Result<[G; OUT_53], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9489,7 +9516,7 @@ fn aiur_fn_51(
         let __v_15: G = __loaded[6];
         let __v_16: G = __loaded[7];
         let __v_17: G = __loaded[8];
-        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__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];
@@ -9499,28 +9526,28 @@ fn aiur_fn_51(
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
         let __v_26: G = __r_arr[8];
-        let __ret: [G; OUT_51] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_53] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[51].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_53] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_52: usize = 10;
-const IN_52: usize = 10;
-const OUT_52: usize = 1;
-fn aiur_fn_52(
-  inp: [G; IN_52],
+const INPUT_SIZE_54: usize = 10;
+const IN_54: usize = 10;
+const OUT_54: usize = 1;
+fn aiur_fn_54(
+  inp: [G; IN_54],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_52], ExecError> {
+) -> Result<[G; OUT_54], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9537,12 +9564,12 @@ fn aiur_fn_52(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_52] = [__v_12];
-        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_54] = [__v_12];
+        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__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];
@@ -9551,7 +9578,7 @@ fn aiur_fn_52(
         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_51] = { let __args: [G; IN_51] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__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];
@@ -9562,12 +9589,12 @@ fn aiur_fn_52(
         let __v_25: G = __r_arr[7];
         let __v_26: G = __r_arr[8];
         let __v_27: G = G::from_u64(0);
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_27, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_29];
-        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_54] = [__v_29];
+        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
@@ -9600,14 +9627,14 @@ fn aiur_fn_52(
         let __v_34: G = G::from_u64(0);
         let __v_35: G = G::from_u64(0);
         let __v_36: G = G::from_u64(0);
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_39];
-        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_54] = [__v_39];
+        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
@@ -9640,22 +9667,22 @@ fn aiur_fn_52(
         let __v_34: G = G::from_u64(0);
         let __v_35: G = G::from_u64(0);
         let __v_36: G = G::from_u64(0);
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_39];
-        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_54] = [__v_39];
+        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_10: G = G::from_u64(3);
         let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[37].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[37].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[37].bump_multiplicity(__i); } let __ret: [G; OUT_37] = unsafe { *(record.function_queries[37].output_at(__i).as_ptr() as *const [G; OUT_37]) }; __ret }, _ => aiur_fn_37(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_52] = [__v_11];
-        record.function_queries[52].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_54] = [__v_11];
+        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -9665,15 +9692,15 @@ fn aiur_fn_52(
   })
 }
 
-const INPUT_SIZE_53: usize = 2;
-const IN_53: usize = 2;
-const OUT_53: usize = 1;
-fn aiur_fn_53(
-  inp: [G; IN_53],
+const INPUT_SIZE_55: usize = 2;
+const IN_55: usize = 2;
+const OUT_55: usize = 1;
+fn aiur_fn_55(
+  inp: [G; IN_55],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_53], ExecError> {
+) -> Result<[G; OUT_55], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9683,8 +9710,8 @@ fn aiur_fn_53(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_53] = [__v_1];
-        record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_55] = [__v_1];
+        record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -9707,12 +9734,12 @@ fn aiur_fn_53(
         let __v_20: G = __loaded[15];
         let __v_21: G = __loaded[16];
         let __v_22: G = __loaded[17];
-        let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __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; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_53] = [__v_24];
-        record.function_queries[53].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_55] = [__v_24];
+        record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -9722,15 +9749,15 @@ fn aiur_fn_53(
   })
 }
 
-const INPUT_SIZE_54: usize = 2;
-const IN_54: usize = 2;
-const OUT_54: usize = 1;
-fn aiur_fn_54(
-  inp: [G; IN_54],
+const INPUT_SIZE_56: usize = 2;
+const IN_56: usize = 2;
+const OUT_56: usize = 1;
+fn aiur_fn_56(
+  inp: [G; IN_56],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_54], ExecError> {
+) -> Result<[G; OUT_56], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9740,8 +9767,8 @@ fn aiur_fn_54(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_54] = [__v_1];
-        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_56] = [__v_1];
+        record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -9755,12 +9782,12 @@ fn aiur_fn_54(
         let __v_11: G = __loaded[6];
         let __v_12: G = __loaded[7];
         let __v_13: G = __loaded[8];
-        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_52] = { let __args: [G; IN_52] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[52].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[52].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[52].bump_multiplicity(__i); } let __ret: [G; OUT_52] = unsafe { *(record.function_queries[52].output_at(__i).as_ptr() as *const [G; OUT_52]) }; __ret }, _ => aiur_fn_52(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_54] = [__v_15];
-        record.function_queries[54].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_56] = [__v_15];
+        record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -9770,15 +9797,15 @@ fn aiur_fn_54(
   })
 }
 
-const INPUT_SIZE_55: usize = 2;
-const IN_55: usize = 2;
-const OUT_55: usize = 1;
-fn aiur_fn_55(
-  inp: [G; IN_55],
+const INPUT_SIZE_57: usize = 2;
+const IN_57: usize = 2;
+const OUT_57: usize = 1;
+fn aiur_fn_57(
+  inp: [G; IN_57],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_55], ExecError> {
+) -> Result<[G; OUT_57], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9788,17 +9815,17 @@ fn aiur_fn_55(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_55] = [__v_1];
-        record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_57] = [__v_1];
+        record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[57].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => aiur_fn_57(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_55] = [__v_6];
-        record.function_queries[55].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_57] = [__v_6];
+        record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -9808,15 +9835,67 @@ fn aiur_fn_55(
   })
 }
 
-const INPUT_SIZE_56: usize = 13;
-const IN_56: usize = 13;
-const OUT_56: usize = 1;
-fn aiur_fn_56(
-  inp: [G; IN_56],
+const INPUT_SIZE_58: usize = 2;
+const IN_58: usize = 2;
+const OUT_58: usize = 1;
+fn aiur_fn_58(
+  inp: [G; IN_58],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_56], ExecError> {
+) -> Result<[G; OUT_58], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_4];
+        record.function_queries[58].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_4];
+        record.function_queries[58].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_4];
+        record.function_queries[58].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_58] = [__v_4];
+        record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_59: usize = 13;
+const IN_59: usize = 13;
+const OUT_59: usize = 1;
+fn aiur_fn_59(
+  inp: [G; IN_59],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_59], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9871,7 +9950,7 @@ fn aiur_fn_56(
         let __v_46: G = __loaded[15];
         let __v_47: G = __loaded[16];
         let __v_48: G = __loaded[17];
-        let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[49].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[49].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[49].bump_multiplicity(__i); } let __ret: [G; OUT_49] = unsafe { *(record.function_queries[49].output_at(__i).as_ptr() as *const [G; OUT_49]) }; __ret }, _ => aiur_fn_49(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_51] = { let __args: [G; IN_51] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[51].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[51].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[51].bump_multiplicity(__i); } let __ret: [G; OUT_51] = unsafe { *(record.function_queries[51].output_at(__i).as_ptr() as *const [G; OUT_51]) }; __ret }, _ => aiur_fn_51(__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_34] = { let __args: [G; IN_34] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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; let __hit = record.function_queries[34].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[34].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[34].bump_multiplicity(__i); } let __ret: [G; OUT_34] = unsafe { *(record.function_queries[34].output_at(__i).as_ptr() as *const [G; OUT_34]) }; __ret }, _ => aiur_fn_34(__args, record, io_buffer, __cu)? } };
@@ -9881,23 +9960,23 @@ fn aiur_fn_56(
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_56] = [__v_54];
-        record.function_queries[56].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_59] = [__v_54];
+        record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_57: usize = 10;
-const IN_57: usize = 10;
-const OUT_57: usize = 1;
-fn aiur_fn_57(
-  inp: [G; IN_57],
+const INPUT_SIZE_60: usize = 10;
+const IN_60: usize = 10;
+const OUT_60: usize = 1;
+fn aiur_fn_60(
+  inp: [G; IN_60],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_57], ExecError> {
+) -> Result<[G; OUT_60], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9934,23 +10013,23 @@ fn aiur_fn_57(
         let __v_28: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_29: G = __r_arr[0];
-        let __ret: [G; OUT_57] = [__v_29];
-        record.function_queries[57].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_60] = [__v_29];
+        record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_58: usize = 2;
-const IN_58: usize = 2;
-const OUT_58: usize = 1;
-fn aiur_fn_58(
-  inp: [G; IN_58],
+const INPUT_SIZE_61: usize = 2;
+const IN_61: usize = 2;
+const OUT_61: usize = 1;
+fn aiur_fn_61(
+  inp: [G; IN_61],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_58], ExecError> {
+) -> Result<[G; OUT_61], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -9968,17 +10047,17 @@ fn aiur_fn_58(
     let __v_12: G = __loaded[10];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_58] = [__v_1];
-        record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_61] = [__v_1];
+        record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[61].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => aiur_fn_61(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[57].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => aiur_fn_57(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_58] = [__v_14];
-        record.function_queries[58].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_61] = [__v_14];
+        record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -9988,15 +10067,15 @@ fn aiur_fn_58(
   })
 }
 
-const INPUT_SIZE_59: usize = 45;
-const IN_59: usize = 45;
-const OUT_59: usize = 1;
-fn aiur_fn_59(
-  inp: [G; IN_59],
+const INPUT_SIZE_62: usize = 45;
+const IN_62: usize = 45;
+const OUT_62: usize = 1;
+fn aiur_fn_62(
+  inp: [G; IN_62],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_59], ExecError> {
+) -> Result<[G; OUT_62], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10067,7 +10146,7 @@ fn aiur_fn_59(
         let __v_63: G = G::from_u64(2);
         let __v_64: G = (__v_63 * __v_1);
         let __v_65: G = (__v_0 + __v_64);
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__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];
@@ -10077,7 +10156,7 @@ fn aiur_fn_59(
         let __v_72: G = __r_arr[6];
         let __v_73: G = __r_arr[7];
         let __v_74: G = G::from_u64(0);
-        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[61].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => aiur_fn_61(__args, record, io_buffer, __cu)? } };
         let __v_75: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_76: G = __r_arr[0];
@@ -10094,23 +10173,23 @@ fn aiur_fn_59(
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_81]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_59] = [__v_83];
-        record.function_queries[59].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_62] = [__v_83];
+        record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_60: usize = 11;
-const IN_60: usize = 11;
-const OUT_60: usize = 1;
-fn aiur_fn_60(
-  inp: [G; IN_60],
+const INPUT_SIZE_63: usize = 11;
+const IN_63: usize = 11;
+const OUT_63: usize = 1;
+fn aiur_fn_63(
+  inp: [G; IN_63],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_60], ExecError> {
+) -> Result<[G; OUT_63], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10150,23 +10229,23 @@ fn aiur_fn_60(
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_60] = [__v_32];
-        record.function_queries[60].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_63] = [__v_32];
+        record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_61: usize = 11;
-const IN_61: usize = 11;
-const OUT_61: usize = 1;
-fn aiur_fn_61(
-  inp: [G; IN_61],
+const INPUT_SIZE_64: usize = 11;
+const IN_64: usize = 11;
+const OUT_64: usize = 1;
+fn aiur_fn_64(
+  inp: [G; IN_64],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_61], ExecError> {
+) -> Result<[G; OUT_64], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10204,25 +10283,25 @@ fn aiur_fn_61(
         let __v_29: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_30: G = __r_arr[0];
-        let __r_arr: [G; OUT_40] = { let __args: [G; IN_40] = [__v_0, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[40].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[40].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[40].bump_multiplicity(__i); } let __ret: [G; OUT_40] = unsafe { *(record.function_queries[40].output_at(__i).as_ptr() as *const [G; OUT_40]) }; __ret }, _ => aiur_fn_40(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_58] = { let __args: [G; IN_58] = [__v_0, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[58].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[58].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[58].bump_multiplicity(__i); } let __ret: [G; OUT_58] = unsafe { *(record.function_queries[58].output_at(__i).as_ptr() as *const [G; OUT_58]) }; __ret }, _ => aiur_fn_58(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
-        let __ret: [G; OUT_61] = [__v_31];
-        record.function_queries[61].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_64] = [__v_31];
+        record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_62: usize = 35;
-const IN_62: usize = 35;
-const OUT_62: usize = 1;
-fn aiur_fn_62(
-  inp: [G; IN_62],
+const INPUT_SIZE_65: usize = 35;
+const IN_65: usize = 35;
+const OUT_65: usize = 1;
+fn aiur_fn_65(
+  inp: [G; IN_65],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_62], ExecError> {
+) -> Result<[G; OUT_65], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10292,23 +10371,23 @@ fn aiur_fn_62(
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_62] = [__v_59];
-        record.function_queries[62].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_65] = [__v_59];
+        record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_63: usize = 2;
-const IN_63: usize = 2;
-const OUT_63: usize = 1;
-fn aiur_fn_63(
-  inp: [G; IN_63],
+const INPUT_SIZE_66: usize = 2;
+const IN_66: usize = 2;
+const OUT_66: usize = 1;
+fn aiur_fn_66(
+  inp: [G; IN_66],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_63], ExecError> {
+) -> Result<[G; OUT_66], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10351,17 +10430,17 @@ fn aiur_fn_63(
     let __v_37: G = __loaded[35];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_63] = [__v_1];
-        record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_66] = [__v_1];
+        record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_37, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_37, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[62].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[62].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => aiur_fn_62(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __ret: [G; OUT_63] = [__v_39];
-        record.function_queries[63].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_66] = [__v_39];
+        record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -10371,15 +10450,15 @@ fn aiur_fn_63(
   })
 }
 
-const INPUT_SIZE_64: usize = 28;
-const IN_64: usize = 28;
-const OUT_64: usize = 1;
-fn aiur_fn_64(
-  inp: [G; IN_64],
+const INPUT_SIZE_67: usize = 28;
+const IN_67: usize = 28;
+const OUT_67: usize = 1;
+fn aiur_fn_67(
+  inp: [G; IN_67],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_64], ExecError> {
+) -> Result<[G; OUT_67], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10430,7 +10509,7 @@ fn aiur_fn_64(
         let __v_43: G = __loaded[15];
         let __v_44: G = __loaded[16];
         let __v_45: G = __loaded[17];
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__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];
@@ -10440,7 +10519,7 @@ fn aiur_fn_64(
         let __v_52: G = __r_arr[6];
         let __v_53: G = __r_arr[7];
         let __v_54: G = G::from_u64(0);
-        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } };
         let __v_55: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
@@ -10453,23 +10532,23 @@ fn aiur_fn_64(
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_64] = [__v_61];
-        record.function_queries[64].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_67] = [__v_61];
+        record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_65: usize = 10;
-const IN_65: usize = 10;
-const OUT_65: usize = 1;
-fn aiur_fn_65(
-  inp: [G; IN_65],
+const INPUT_SIZE_68: usize = 10;
+const IN_68: usize = 10;
+const OUT_68: usize = 1;
+fn aiur_fn_68(
+  inp: [G; IN_68],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_65], ExecError> {
+) -> Result<[G; OUT_68], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10483,27 +10562,27 @@ fn aiur_fn_65(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_65] = [__v_11];
-        record.function_queries[65].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_68] = [__v_11];
+        record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_66: usize = 18;
-const IN_66: usize = 18;
-const OUT_66: usize = 1;
-fn aiur_fn_66(
-  inp: [G; IN_66],
+const INPUT_SIZE_69: usize = 18;
+const IN_69: usize = 18;
+const OUT_69: usize = 1;
+fn aiur_fn_69(
+  inp: [G; IN_69],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_66], ExecError> {
+) -> Result<[G; OUT_69], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10525,29 +10604,29 @@ fn aiur_fn_66(
     let __v_17: G = inp[17];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __ret: [G; OUT_66] = [__v_20];
-        record.function_queries[66].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_69] = [__v_20];
+        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_67: usize = 46;
-const IN_67: usize = 46;
-const OUT_67: usize = 1;
-fn aiur_fn_67(
-  inp: [G; IN_67],
+const INPUT_SIZE_70: usize = 46;
+const IN_70: usize = 46;
+const OUT_70: usize = 1;
+fn aiur_fn_70(
+  inp: [G; IN_70],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_67], ExecError> {
+) -> Result<[G; OUT_70], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10599,31 +10678,31 @@ fn aiur_fn_67(
       0u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(0);
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } };
         let __v_48: G = __r_arr[0];
         let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_67] = [__v_49];
-        record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_70] = [__v_49];
+        record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(1);
-        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[64].bump_multiplicity(__i); } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_67] = [__v_49];
-        record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_70] = [__v_49];
+        record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_46: G = G::from_u64(0);
         let __v_47: G = G::from_u64(2);
-        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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; let __hit = record.function_queries[62].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[62].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => aiur_fn_62(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_67] = [__v_49];
-        record.function_queries[67].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_70] = [__v_49];
+        record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -10633,15 +10712,15 @@ fn aiur_fn_67(
   })
 }
 
-const INPUT_SIZE_68: usize = 2;
-const IN_68: usize = 2;
-const OUT_68: usize = 1;
-fn aiur_fn_68(
-  inp: [G; IN_68],
+const INPUT_SIZE_71: usize = 2;
+const IN_71: usize = 2;
+const OUT_71: usize = 1;
+fn aiur_fn_71(
+  inp: [G; IN_71],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_68], ExecError> {
+) -> Result<[G; OUT_71], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10695,17 +10774,17 @@ fn aiur_fn_68(
     let __v_48: G = __loaded[46];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_68] = [__v_1];
-        record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_71] = [__v_1];
+        record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } };
         let __v_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[67].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[67].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[67].bump_multiplicity(__i); } let __ret: [G; OUT_67] = unsafe { *(record.function_queries[67].output_at(__i).as_ptr() as *const [G; OUT_67]) }; __ret }, _ => aiur_fn_67(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } };
         let __v_50: G = __r_arr[0];
-        let __ret: [G; OUT_68] = [__v_50];
-        record.function_queries[68].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_71] = [__v_50];
+        record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -10715,15 +10794,15 @@ fn aiur_fn_68(
   })
 }
 
-const INPUT_SIZE_69: usize = 46;
-const IN_69: usize = 46;
-const OUT_69: usize = 1;
-fn aiur_fn_69(
-  inp: [G; IN_69],
+const INPUT_SIZE_72: usize = 46;
+const IN_72: usize = 46;
+const OUT_72: usize = 1;
+fn aiur_fn_72(
+  inp: [G; IN_72],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_69], ExecError> {
+) -> Result<[G; OUT_72], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10773,59 +10852,59 @@ fn aiur_fn_69(
     let __v_45: G = inp[45];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[59].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[59].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[59].bump_multiplicity(__i); } let __ret: [G; OUT_59] = unsafe { *(record.function_queries[59].output_at(__i).as_ptr() as *const [G; OUT_59]) }; __ret }, _ => aiur_fn_59(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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; let __hit = record.function_queries[62].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[62].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[62].bump_multiplicity(__i); } let __ret: [G; OUT_62] = unsafe { *(record.function_queries[62].output_at(__i).as_ptr() as *const [G; OUT_62]) }; __ret }, _ => aiur_fn_62(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[60].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[60].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[60].bump_multiplicity(__i); } let __ret: [G; OUT_60] = unsafe { *(record.function_queries[60].output_at(__i).as_ptr() as *const [G; OUT_60]) }; __ret }, _ => aiur_fn_60(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_63] = { let __args: [G; IN_63] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[63].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[63].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[63].bump_multiplicity(__i); } let __ret: [G; OUT_63] = unsafe { *(record.function_queries[63].output_at(__i).as_ptr() as *const [G; OUT_63]) }; __ret }, _ => aiur_fn_63(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_61] = { let __args: [G; IN_61] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[61].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[61].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[61].bump_multiplicity(__i); } let __ret: [G; OUT_61] = unsafe { *(record.function_queries[61].output_at(__i).as_ptr() as *const [G; OUT_61]) }; __ret }, _ => aiur_fn_61(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[64].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[64].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[64].bump_multiplicity(__i); } let __ret: [G; OUT_64] = unsafe { *(record.function_queries[64].output_at(__i).as_ptr() as *const [G; OUT_64]) }; __ret }, _ => aiur_fn_64(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[66].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[66].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[66].bump_multiplicity(__i); } let __ret: [G; OUT_66] = unsafe { *(record.function_queries[66].output_at(__i).as_ptr() as *const [G; OUT_66]) }; __ret }, _ => aiur_fn_66(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[65].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[65].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[65].bump_multiplicity(__i); } let __ret: [G; OUT_65] = unsafe { *(record.function_queries[65].output_at(__i).as_ptr() as *const [G; OUT_65]) }; __ret }, _ => aiur_fn_65(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } };
         let __v_46: G = __r_arr[0];
-        let __ret: [G; OUT_69] = [__v_46];
-        record.function_queries[69].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_72] = [__v_46];
+        record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -10835,19 +10914,19 @@ fn aiur_fn_69(
   })
 }
 
-const INPUT_SIZE_70: usize = 2;
-const IN_70: usize = 2;
-const OUT_70: usize = 1;
-fn aiur_fn_70(
-  inp: [G; IN_70],
+const INPUT_SIZE_73: usize = 2;
+const IN_73: usize = 2;
+const OUT_73: usize = 1;
+fn aiur_fn_73(
+  inp: [G; IN_73],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_70], ExecError> {
+) -> Result<[G; OUT_73], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__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];
@@ -10856,29 +10935,29 @@ fn aiur_fn_70(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[53].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[53].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[53].bump_multiplicity(__i); } let __ret: [G; OUT_53] = unsafe { *(record.function_queries[53].output_at(__i).as_ptr() as *const [G; OUT_53]) }; __ret }, _ => aiur_fn_53(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_70] = [__v_11];
-    record.function_queries[70].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_73] = [__v_11];
+    record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_71: usize = 2;
-const IN_71: usize = 2;
-const OUT_71: usize = 1;
-fn aiur_fn_71(
-  inp: [G; IN_71],
+const INPUT_SIZE_74: usize = 2;
+const IN_74: usize = 2;
+const OUT_74: usize = 1;
+fn aiur_fn_74(
+  inp: [G; IN_74],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_71], ExecError> {
+) -> Result<[G; OUT_74], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__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];
@@ -10887,29 +10966,29 @@ fn aiur_fn_71(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[55].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[55].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[55].bump_multiplicity(__i); } let __ret: [G; OUT_55] = unsafe { *(record.function_queries[55].output_at(__i).as_ptr() as *const [G; OUT_55]) }; __ret }, _ => aiur_fn_55(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[57].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[57].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[57].bump_multiplicity(__i); } let __ret: [G; OUT_57] = unsafe { *(record.function_queries[57].output_at(__i).as_ptr() as *const [G; OUT_57]) }; __ret }, _ => aiur_fn_57(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_71] = [__v_11];
-    record.function_queries[71].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_74] = [__v_11];
+    record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_72: usize = 2;
-const IN_72: usize = 2;
-const OUT_72: usize = 1;
-fn aiur_fn_72(
-  inp: [G; IN_72],
+const INPUT_SIZE_75: usize = 2;
+const IN_75: usize = 2;
+const OUT_75: usize = 1;
+fn aiur_fn_75(
+  inp: [G; IN_75],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_72], ExecError> {
+) -> Result<[G; OUT_75], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__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];
@@ -10918,25 +10997,25 @@ fn aiur_fn_72(
     let __v_7: G = __r_arr[5];
     let __v_8: G = __r_arr[6];
     let __v_9: G = __r_arr[7];
-    let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[54].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[54].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[54].bump_multiplicity(__i); } let __ret: [G; OUT_54] = unsafe { *(record.function_queries[54].output_at(__i).as_ptr() as *const [G; OUT_54]) }; __ret }, _ => aiur_fn_54(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_56] = { let __args: [G; IN_56] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[56].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[56].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[56].bump_multiplicity(__i); } let __ret: [G; OUT_56] = unsafe { *(record.function_queries[56].output_at(__i).as_ptr() as *const [G; OUT_56]) }; __ret }, _ => aiur_fn_56(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[36].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[36].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[36].bump_multiplicity(__i); } let __ret: [G; OUT_36] = unsafe { *(record.function_queries[36].output_at(__i).as_ptr() as *const [G; OUT_36]) }; __ret }, _ => aiur_fn_36(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_72] = [__v_11];
-    record.function_queries[72].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_75] = [__v_11];
+    record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_73: usize = 49;
-const IN_73: usize = 49;
-const OUT_73: usize = 1;
-fn aiur_fn_73(
-  inp: [G; IN_73],
+const INPUT_SIZE_76: usize = 49;
+const IN_76: usize = 49;
+const OUT_76: usize = 1;
+fn aiur_fn_76(
+  inp: [G; IN_76],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_73], ExecError> {
+) -> Result<[G; OUT_76], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -10989,15 +11068,15 @@ fn aiur_fn_73(
     let __v_48: G = inp[48];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } };
         let __v_49: G = __r_arr[0];
-        let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
         let __v_50: G = __r_arr[0];
-        let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_45, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[70].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[70].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[70].bump_multiplicity(__i); } let __ret: [G; OUT_70] = unsafe { *(record.function_queries[70].output_at(__i).as_ptr() as *const [G; OUT_70]) }; __ret }, _ => aiur_fn_70(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_45, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } };
         let __v_51: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__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];
@@ -11007,12 +11086,12 @@ fn aiur_fn_73(
             let __v_58: G = __r_arr[6];
             let __v_59: G = __r_arr[7];
             let __v_60: G = G::from_u64(12);
-            let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_1, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[68].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[68].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[68].bump_multiplicity(__i); } let __ret: [G; OUT_68] = unsafe { *(record.function_queries[68].output_at(__i).as_ptr() as *const [G; OUT_68]) }; __ret }, _ => aiur_fn_68(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[71].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[71].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[71].bump_multiplicity(__i); } let __ret: [G; OUT_71] = unsafe { *(record.function_queries[71].output_at(__i).as_ptr() as *const [G; OUT_71]) }; __ret }, _ => aiur_fn_71(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_60, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -11025,12 +11104,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
@@ -11043,12 +11122,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
@@ -11061,12 +11140,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
@@ -11079,12 +11158,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
@@ -11097,12 +11176,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           5u64 => {
@@ -11115,12 +11194,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           6u64 => {
@@ -11133,12 +11212,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           7u64 => {
@@ -11151,12 +11230,12 @@ fn aiur_fn_73(
             let __v_58: G = G::from_u64(0);
             let __v_59: G = G::from_u64(0);
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[69].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[69].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[69].bump_multiplicity(__i); } let __ret: [G; OUT_69] = unsafe { *(record.function_queries[69].output_at(__i).as_ptr() as *const [G; OUT_69]) }; __ret }, _ => aiur_fn_69(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_72] = { let __args: [G; IN_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_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[72].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[72].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[72].bump_multiplicity(__i); } let __ret: [G; OUT_72] = unsafe { *(record.function_queries[72].output_at(__i).as_ptr() as *const [G; OUT_72]) }; __ret }, _ => aiur_fn_72(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[38].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[38].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[38].bump_multiplicity(__i); } let __ret: [G; OUT_38] = unsafe { *(record.function_queries[38].output_at(__i).as_ptr() as *const [G; OUT_38]) }; __ret }, _ => aiur_fn_38(__args, record, io_buffer, __cu)? } };
             let __v_62: G = __r_arr[0];
-            let __ret: [G; OUT_73] = [__v_62];
-            record.function_queries[73].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_76] = [__v_62];
+            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -11168,15 +11247,15 @@ fn aiur_fn_73(
   })
 }
 
-const INPUT_SIZE_74: usize = 1;
-const IN_74: usize = 1;
-const OUT_74: usize = 2;
-fn aiur_fn_74(
-  inp: [G; IN_74],
+const INPUT_SIZE_77: usize = 1;
+const IN_77: usize = 1;
+const OUT_77: usize = 2;
+fn aiur_fn_77(
+  inp: [G; IN_77],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_74], ExecError> {
+) -> Result<[G; OUT_77], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -11185,17 +11264,8 @@ fn aiur_fn_74(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_74] = [__v_2, __v_3];
-        record.function_queries[74].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_74] = [__v_4, __v_7];
-        record.function_queries[74].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_77] = [__v_2, __v_3];
+        record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -11205,15 +11275,15 @@ fn aiur_fn_74(
   })
 }
 
-const INPUT_SIZE_75: usize = 2;
-const IN_75: usize = 2;
-const OUT_75: usize = 9;
-fn aiur_fn_75(
-  inp: [G; IN_75],
+const INPUT_SIZE_78: usize = 2;
+const IN_78: usize = 2;
+const OUT_78: usize = 9;
+fn aiur_fn_78(
+  inp: [G; IN_78],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_75], ExecError> {
+) -> Result<[G; OUT_78], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11227,8 +11297,8 @@ fn aiur_fn_75(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_75] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
-        record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_78] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0];
+        record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -11240,7 +11310,7 @@ fn aiur_fn_75(
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__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];
@@ -11250,8 +11320,8 @@ fn aiur_fn_75(
             let __v_13: G = __r_arr[6];
             let __v_14: G = __r_arr[7];
             let __v_15: G = __r_arr[8];
-            let __ret: [G; OUT_75] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
-            record.function_queries[75].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_78] = [__v_3, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15];
+            record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -11263,15 +11333,15 @@ fn aiur_fn_75(
   })
 }
 
-const INPUT_SIZE_76: usize = 1;
-const IN_76: usize = 1;
-const OUT_76: usize = 9;
-fn aiur_fn_76(
-  inp: [G; IN_76],
+const INPUT_SIZE_79: usize = 1;
+const IN_79: usize = 1;
+const OUT_79: usize = 9;
+fn aiur_fn_79(
+  inp: [G; IN_79],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_76], ExecError> {
+) -> Result<[G; OUT_79], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -11316,8 +11386,8 @@ fn aiur_fn_76(
             let __v_34: G = G::from_u64(0);
             let __v_35: G = G::from_u64(0);
             let __v_36: G = G::from_u64(0);
-            let __ret: [G; OUT_76] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
-            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_79] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_3];
+            record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -11329,7 +11399,7 @@ fn aiur_fn_76(
             if (__v_33 != __v_34) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("tag0: payload width exceeds 8 bytes".to_string()) });
             }
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__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];
@@ -11339,8 +11409,28 @@ fn aiur_fn_76(
             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_76] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
-            record.function_queries[76].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } };
+            let __v_44: G = __r_arr[0];
+            if (__v_44 != __v_31) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("nonminimal tag0 width".to_string()) });
+            }
+            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_31.as_canonical_u64() {
+  1u64 => {
+    let __v_45: G = G::from_u64(128);
+    let __v_46: G = if unconstrained { Bytes2::less_than(&__v_35, &__v_45) } else { bytes2_less_than_value(__v_35, __v_45, record) };
+    let __v_47: G = G::from_u64(0);
+    if (__v_46 != __v_47) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64(), msg: Some("nonminimal tag0 value".to_string()) });
+    }
+    break '__mc_0 [];
+  },
+  _ => {
+    break '__mc_0 [];
+  },
+}
+ };
+            let __ret: [G; OUT_79] = [__v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
+            record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -11352,15 +11442,15 @@ fn aiur_fn_76(
   })
 }
 
-const INPUT_SIZE_77: usize = 1;
-const IN_77: usize = 1;
-const OUT_77: usize = 10;
-fn aiur_fn_77(
-  inp: [G; IN_77],
+const INPUT_SIZE_80: usize = 1;
+const IN_80: usize = 1;
+const OUT_80: usize = 10;
+fn aiur_fn_80(
+  inp: [G; IN_80],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_77], ExecError> {
+) -> Result<[G; OUT_80], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -11402,8 +11492,8 @@ fn aiur_fn_77(
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_77] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_80] = [__v_14, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -11415,7 +11505,7 @@ fn aiur_fn_77(
             if (__v_30 != __v_31) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("tag2: payload width exceeds 8 bytes".to_string()) });
             }
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
             let __v_34: G = __r_arr[2];
@@ -11425,8 +11515,28 @@ fn aiur_fn_77(
             let __v_38: G = __r_arr[6];
             let __v_39: G = __r_arr[7];
             let __v_40: G = __r_arr[8];
-            let __ret: [G; OUT_77] = [__v_14, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
-            record.function_queries[77].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } };
+            let __v_41: G = __r_arr[0];
+            if (__v_41 != __v_28) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("nonminimal tag2 width".to_string()) });
+            }
+            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_28.as_canonical_u64() {
+  1u64 => {
+    let __v_42: G = G::from_u64(32);
+    let __v_43: G = if unconstrained { Bytes2::less_than(&__v_32, &__v_42) } else { bytes2_less_than_value(__v_32, __v_42, record) };
+    let __v_44: G = G::from_u64(0);
+    if (__v_43 != __v_44) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_44.as_canonical_u64(), msg: Some("nonminimal tag2 value".to_string()) });
+    }
+    break '__mc_0 [];
+  },
+  _ => {
+    break '__mc_0 [];
+  },
+}
+ };
+            let __ret: [G; OUT_80] = [__v_14, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40];
+            record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -11438,15 +11548,15 @@ fn aiur_fn_77(
   })
 }
 
-const INPUT_SIZE_78: usize = 1;
-const IN_78: usize = 1;
-const OUT_78: usize = 10;
-fn aiur_fn_78(
-  inp: [G; IN_78],
+const INPUT_SIZE_81: usize = 1;
+const IN_81: usize = 1;
+const OUT_81: usize = 10;
+fn aiur_fn_81(
+  inp: [G; IN_81],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_78], ExecError> {
+) -> Result<[G; OUT_81], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -11488,14 +11598,14 @@ fn aiur_fn_78(
             let __v_31: G = G::from_u64(0);
             let __v_32: G = G::from_u64(0);
             let __v_33: G = G::from_u64(0);
-            let __ret: [G; OUT_78] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
-            record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_81] = [__v_20, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_3];
+            record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_27: G = G::from_u64(1);
             let __v_28: G = (__v_26 + __v_27);
-            let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[75].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[75].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[75].bump_multiplicity(__i); } let __ret: [G; OUT_75] = unsafe { *(record.function_queries[75].output_at(__i).as_ptr() as *const [G; OUT_75]) }; __ret }, _ => aiur_fn_75(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_3, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__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];
@@ -11505,8 +11615,28 @@ fn aiur_fn_78(
             let __v_35: G = __r_arr[6];
             let __v_36: G = __r_arr[7];
             let __v_37: G = __r_arr[8];
-            let __ret: [G; OUT_78] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
-            record.function_queries[78].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_4] = { let __args: [G; IN_4] = [__v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[4].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[4].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[4].bump_multiplicity(__i); } let __ret: [G; OUT_4] = unsafe { *(record.function_queries[4].output_at(__i).as_ptr() as *const [G; OUT_4]) }; __ret }, _ => aiur_fn_4(__args, record, io_buffer, __cu)? } };
+            let __v_38: G = __r_arr[0];
+            if (__v_38 != __v_28) {
+              return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("nonminimal tag4 width".to_string()) });
+            }
+            let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_28.as_canonical_u64() {
+  1u64 => {
+    let __v_39: G = G::from_u64(8);
+    let __v_40: G = if unconstrained { Bytes2::less_than(&__v_29, &__v_39) } else { bytes2_less_than_value(__v_29, __v_39, record) };
+    let __v_41: G = G::from_u64(0);
+    if (__v_40 != __v_41) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_41.as_canonical_u64(), msg: Some("nonminimal tag4 value".to_string()) });
+    }
+    break '__mc_0 [];
+  },
+  _ => {
+    break '__mc_0 [];
+  },
+}
+ };
+            let __ret: [G; OUT_81] = [__v_20, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37];
+            record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -11518,15 +11648,15 @@ fn aiur_fn_78(
   })
 }
 
-const INPUT_SIZE_79: usize = 9;
-const IN_79: usize = 9;
-const OUT_79: usize = 2;
-fn aiur_fn_79(
-  inp: [G; IN_79],
+const INPUT_SIZE_82: usize = 9;
+const IN_82: usize = 9;
+const OUT_82: usize = 2;
+fn aiur_fn_82(
+  inp: [G; IN_82],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_79], ExecError> {
+) -> Result<[G; OUT_82], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11544,12 +11674,12 @@ fn aiur_fn_79(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_79] = [__v_12, __v_0];
-        record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_82] = [__v_12, __v_0];
+        record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -11568,13 +11698,13 @@ fn aiur_fn_79(
         let __v_24: G = __r_arr[5];
         let __v_25: G = __r_arr[6];
         let __v_26: G = __r_arr[7];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_79] = [__v_30, __v_28];
-        record.function_queries[79].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_82] = [__v_30, __v_28];
+        record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -11584,218 +11714,8 @@ fn aiur_fn_79(
   })
 }
 
-const INPUT_SIZE_80: usize = 10;
-const IN_80: usize = 10;
-const OUT_80: usize = 2;
-fn aiur_fn_80(
-  inp: [G; IN_80],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_80], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __v_1: G = inp[1];
-    let __v_2: G = inp[2];
-    let __v_3: G = inp[3];
-    let __v_4: G = inp[4];
-    let __v_5: G = inp[5];
-    let __v_6: G = inp[6];
-    let __v_7: G = inp[7];
-    let __v_8: G = inp[8];
-    let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } };
-    let __v_10: G = __r_arr[0];
-    match __v_10.as_canonical_u64() {
-      1u64 => {
-        let __ret: [G; OUT_80] = [__v_0, __v_1];
-        record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained);
-        return Ok(__ret);
-      },
-      0u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-        let __v_11: G = __r_arr[0];
-        let __v_12: G = __r_arr[1];
-        let __v_13: G = G::from_u64(7);
-        let __v_14: G = G::from_u64(0);
-        let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
-        let __v_16: G = __r_arr[0];
-        let __v_17: G = __r_arr[1];
-        let __v_18: G = __r_arr[2];
-        let __v_19: G = __r_arr[3];
-        let __v_20: G = __r_arr[4];
-        let __v_21: G = __r_arr[5];
-        let __v_22: G = __r_arr[6];
-        let __v_23: G = __r_arr[7];
-        let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } };
-        let __v_24: G = __r_arr[0];
-        let __v_25: G = __r_arr[1];
-        let __ret: [G; OUT_80] = [__v_24, __v_25];
-        record.function_queries[80].finish(&inp[..], &__ret[..], !unconstrained);
-        return Ok(__ret);
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_81: usize = 1;
-const IN_81: usize = 1;
-const OUT_81: usize = 2;
-fn aiur_fn_81(
-  inp: [G; IN_81],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(4);
-        let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) };
-        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("invalid lambda mode".to_string()) });
-        }
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_81] = [__v_7, __v_3];
-            record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_81] = [__v_7, __v_3];
-            record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_7: G = G::from_u64(2);
-            let __ret: [G; OUT_81] = [__v_7, __v_3];
-            record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_7: G = G::from_u64(3);
-            let __ret: [G; OUT_81] = [__v_7, __v_3];
-            record.function_queries[81].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_82: usize = 1;
-const IN_82: usize = 1;
-const OUT_82: usize = 3;
-fn aiur_fn_82(
-  inp: [G; IN_82],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_82], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = inp[0];
-    let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
-    let __v_1: G = __loaded[0];
-    let __v_2: G = __loaded[1];
-    let __v_3: G = __loaded[2];
-    match __v_1.as_canonical_u64() {
-      0u64 => {
-        let __v_4: G = G::from_u64(8);
-        let __v_5: G = if unconstrained { Bytes2::less_than(&__v_2, &__v_4) } else { bytes2_less_than_value(__v_2, __v_4, record) };
-        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("invalid forall mode".to_string()) });
-        }
-        match __v_2.as_canonical_u64() {
-          0u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          1u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          2u64 => {
-            let __v_7: G = G::from_u64(2);
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          3u64 => {
-            let __v_7: G = G::from_u64(3);
-            let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          4u64 => {
-            let __v_7: G = G::from_u64(0);
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          5u64 => {
-            let __v_7: G = G::from_u64(1);
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          6u64 => {
-            let __v_7: G = G::from_u64(2);
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          7u64 => {
-            let __v_7: G = G::from_u64(3);
-            let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_82] = [__v_7, __v_8, __v_3];
-            record.function_queries[82].finish(&inp[..], &__ret[..], !unconstrained);
-            return Ok(__ret);
-          },
-          _ => {
-            return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64()));
-          },
-        }
-      },
-      _ => {
-        return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
-      },
-    }
-  })
-}
-
-const INPUT_SIZE_83: usize = 9;
-const IN_83: usize = 9;
+const INPUT_SIZE_83: usize = 10;
+const IN_83: usize = 10;
 const OUT_83: usize = 2;
 fn aiur_fn_83(
   inp: [G; IN_83],
@@ -11803,6 +11723,242 @@ fn aiur_fn_83(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_83], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = inp[4];
+    let __v_5: G = inp[5];
+    let __v_6: G = inp[6];
+    let __v_7: G = inp[7];
+    let __v_8: G = inp[8];
+    let __v_9: G = inp[9];
+    let __r_arr: [G; OUT_5] = { let __args: [G; IN_5] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[5].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[5].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[5].bump_multiplicity(__i); } let __ret: [G; OUT_5] = unsafe { *(record.function_queries[5].output_at(__i).as_ptr() as *const [G; OUT_5]) }; __ret }, _ => aiur_fn_5(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    match __v_10.as_canonical_u64() {
+      1u64 => {
+        let __ret: [G; OUT_83] = [__v_0, __v_1];
+        record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained);
+        return Ok(__ret);
+      },
+      0u64 => {
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+        let __v_11: G = __r_arr[0];
+        let __v_12: G = __r_arr[1];
+        let __v_13: G = G::from_u64(7);
+        let __v_14: G = G::from_u64(0);
+        let __v_15: G = { let __values: [G; 18] = [__v_13, __v_0, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __v_18: G = __r_arr[2];
+        let __v_19: G = __r_arr[3];
+        let __v_20: G = __r_arr[4];
+        let __v_21: G = __r_arr[5];
+        let __v_22: G = __r_arr[6];
+        let __v_23: G = __r_arr[7];
+        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_15, __v_12, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = __r_arr[1];
+        let __ret: [G; OUT_83] = [__v_24, __v_25];
+        record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained);
+        return Ok(__ret);
+      },
+      _ => {
+        return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64()));
+      },
+    }
+  })
+}
+
+const INPUT_SIZE_84: usize = 2;
+const IN_84: usize = 2;
+const OUT_84: usize = 2;
+fn aiur_fn_84(
+  inp: [G; IN_84],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_84], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
+  0u64 => {
+    let __v_2: G = G::from_u64(0);
+    break '__mc_0 [__v_2];
+  },
+  1u64 => {
+    let __v_2: G = G::from_u64(1);
+    break '__mc_0 [__v_2];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64()));
+  },
+}
+ };
+    let __v_2: G = __mc_out___mc_0[0];
+    let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_1.as_canonical_u64() {
+  0u64 => {
+    let __v_3: G = G::from_u64(0);
+    break '__mc_1 [__v_3];
+  },
+  1u64 => {
+    let __v_3: G = G::from_u64(1);
+    break '__mc_1 [__v_3];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64()));
+  },
+}
+ };
+    let __v_3: G = __mc_out___mc_1[0];
+    let __ret: [G; OUT_84] = [__v_2, __v_3];
+    record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_85: usize = 4;
+const IN_85: usize = 4;
+const OUT_85: usize = 3;
+fn aiur_fn_85(
+  inp: [G; IN_85],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_85], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __v_1: G = inp[1];
+    let __v_2: G = inp[2];
+    let __v_3: G = inp[3];
+    let __v_4: G = G::from_u64(2);
+    let __v_5: G = (__v_4 * __v_1);
+    let __v_6: G = (__v_0 + __v_5);
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
+  0u64 => {
+    let __v_7: G = G::from_u64(0);
+    break '__mc_0 [__v_7];
+  },
+  1u64 => {
+    let __v_7: G = G::from_u64(1);
+    break '__mc_0 [__v_7];
+  },
+  2u64 => {
+    let __v_7: G = G::from_u64(2);
+    break '__mc_0 [__v_7];
+  },
+  3u64 => {
+    let __v_7: G = G::from_u64(3);
+    break '__mc_0 [__v_7];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64()));
+  },
+}
+ };
+    let __v_7: G = __mc_out___mc_0[0];
+    let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_8: G = __r_arr[0];
+    let __v_9: G = __r_arr[1];
+    let __ret: [G; OUT_85] = [__v_7, __v_8, __v_9];
+    record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_86: usize = 1;
+const IN_86: usize = 1;
+const OUT_86: usize = 4;
+fn aiur_fn_86(
+  inp: [G; IN_86],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_86], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
+    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 = (__v_9 + __v_10);
+    let __v_12: G = (__v_8 + __v_11);
+    let __v_13: G = (__v_7 + __v_12);
+    let __v_14: G = G::from_u64(0);
+    if (__v_13 != __v_14) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_14.as_canonical_u64(), msg: Some("reserved binder contract bits".to_string()) });
+    }
+    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__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 __ret: [G; OUT_86] = [__v_15, __v_16, __v_17, __v_2];
+    record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_87: usize = 1;
+const IN_87: usize = 1;
+const OUT_87: usize = 6;
+fn aiur_fn_87(
+  inp: [G; IN_87],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_87], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = inp[0];
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __v_1: G = __r_arr[0];
+    let __v_2: G = __r_arr[1];
+    let __b1_out: [G; 8] = if unconstrained { let __v: Vec<G> = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) };
+    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 = (__v_9 + __v_10);
+    let __v_12: G = G::from_u64(0);
+    if (__v_11 != __v_12) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("reserved forall contract bits".to_string()) });
+    }
+    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } };
+    let __v_16: G = __r_arr[0];
+    let __v_17: G = __r_arr[1];
+    let __ret: [G; OUT_87] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_2];
+    record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_88: usize = 9;
+const IN_88: usize = 9;
+const OUT_88: usize = 2;
+fn aiur_fn_88(
+  inp: [G; IN_88],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_88], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11817,7 +11973,7 @@ fn aiur_fn_83(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
@@ -11846,41 +12002,43 @@ fn aiur_fn_83(
             if (__v_30 != __v_31) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical lambda telescope".to_string()) });
             }
-            let __ret: [G; OUT_83] = [__v_10, __v_11];
-            record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_88] = [__v_10, __v_11];
+            record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_83] = [__v_10, __v_11];
-            record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_88] = [__v_10, __v_11];
+            record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-        let __v_12: G = __r_arr[0];
-        let __v_13: G = __r_arr[1];
-        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __v_12: G = __r_arr[2];
+        let __v_13: G = __r_arr[3];
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __v_16: G = __r_arr[2];
-        let __v_17: G = __r_arr[3];
-        let __v_18: G = __r_arr[4];
-        let __v_19: G = __r_arr[5];
-        let __v_20: G = __r_arr[6];
-        let __v_21: G = __r_arr[7];
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__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(8);
-        let __v_25: G = G::from_u64(0);
-        let __v_26: G = { let __values: [G; 18] = [__v_24, __v_10, __v_12, __v_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]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_83] = [__v_26, __v_23];
-        record.function_queries[83].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
+        let __v_18: G = __r_arr[2];
+        let __v_19: G = __r_arr[3];
+        let __v_20: G = __r_arr[4];
+        let __v_21: G = __r_arr[5];
+        let __v_22: G = __r_arr[6];
+        let __v_23: G = __r_arr[7];
+        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __v_24: G = __r_arr[0];
+        let __v_25: G = __r_arr[1];
+        let __v_26: G = G::from_u64(8);
+        let __v_27: G = G::from_u64(0);
+        let __v_28: G = { let __values: [G; 18] = [__v_26, __v_10, __v_11, __v_12, __v_14, __v_24, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_88] = [__v_28, __v_25];
+        record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -11890,15 +12048,15 @@ fn aiur_fn_83(
   })
 }
 
-const INPUT_SIZE_84: usize = 9;
-const IN_84: usize = 9;
-const OUT_84: usize = 2;
-fn aiur_fn_84(
-  inp: [G; IN_84],
+const INPUT_SIZE_89: usize = 9;
+const IN_89: usize = 9;
+const OUT_89: usize = 2;
+fn aiur_fn_89(
+  inp: [G; IN_89],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_84], ExecError> {
+) -> Result<[G; OUT_89], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -11913,7 +12071,7 @@ fn aiur_fn_84(
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
@@ -11942,42 +12100,45 @@ fn aiur_fn_84(
             if (__v_30 != __v_31) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_31.as_canonical_u64(), msg: Some("non-canonical forall telescope".to_string()) });
             }
-            let __ret: [G; OUT_84] = [__v_10, __v_11];
-            record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_89] = [__v_10, __v_11];
+            record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_84] = [__v_10, __v_11];
-            record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_89] = [__v_10, __v_11];
+            record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => aiur_fn_82(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__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 __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-        let __v_13: G = __r_arr[0];
-        let __v_14: G = __r_arr[1];
+        let __v_13: G = __r_arr[3];
+        let __v_14: G = __r_arr[4];
+        let __v_15: G = __r_arr[5];
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+        let __v_16: G = __r_arr[0];
+        let __v_17: G = __r_arr[1];
         let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__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 __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } };
-        let __v_23: G = __r_arr[0];
-        let __v_24: G = __r_arr[1];
-        let __v_25: G = G::from_u64(9);
-        let __v_26: G = G::from_u64(0);
-        let __v_27: G = { let __values: [G; 18] = [__v_25, __v_10, __v_11, __v_13, __v_23, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_84] = [__v_27, __v_24];
-        record.function_queries[84].finish(&inp[..], &__ret[..], !unconstrained);
+        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 __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => 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(9);
+        let __v_29: G = G::from_u64(0);
+        let __v_30: G = { let __values: [G; 18] = [__v_28, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16, __v_26, __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(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+        let __ret: [G; OUT_89] = [__v_30, __v_27];
+        record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -11987,18 +12148,18 @@ fn aiur_fn_84(
   })
 }
 
-const INPUT_SIZE_85: usize = 1;
-const IN_85: usize = 1;
-const OUT_85: usize = 2;
-fn aiur_fn_85(
-  inp: [G; IN_85],
+const INPUT_SIZE_90: usize = 1;
+const IN_90: usize = 1;
+const OUT_90: usize = 2;
+fn aiur_fn_90(
+  inp: [G; IN_90],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_85], ExecError> {
+) -> Result<[G; OUT_90], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12014,20 +12175,20 @@ fn aiur_fn_85(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_13, __v_10];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_10];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_11: G = G::from_u64(1);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_13, __v_10];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_10];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12037,18 +12198,18 @@ fn aiur_fn_85(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => 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(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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_24, __v_21];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_24, __v_21];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12058,18 +12219,18 @@ fn aiur_fn_85(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[82].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[82].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[82].bump_multiplicity(__i); } let __ret: [G; OUT_82] = unsafe { *(record.function_queries[82].output_at(__i).as_ptr() as *const [G; OUT_82]) }; __ret }, _ => 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(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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_24, __v_21];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_24, __v_21];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -12079,29 +12240,29 @@ fn aiur_fn_85(
         let __v_17: G = __r_arr[6];
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = __r_arr[1];
         let __v_22: G = G::from_u64(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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_23, __v_21];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_23, __v_21];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_11: G = G::from_u64(5);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_13, __v_10];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_10];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_11: G = G::from_u64(6);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_13, __v_10];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_10];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
@@ -12111,7 +12272,7 @@ fn aiur_fn_85(
         if (__v_11 != __v_12) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("App with zero arguments".to_string()) });
         }
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
         let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
@@ -12140,19 +12301,19 @@ fn aiur_fn_85(
             if (__v_33 != __v_34) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_34.as_canonical_u64(), msg: Some("non-canonical application telescope".to_string()) });
             }
-            let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __ret: [G; OUT_85] = [__v_35, __v_36];
-            record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_90] = [__v_35, __v_36];
+            record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_13, __v_14, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } };
             let __v_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __ret: [G; OUT_85] = [__v_33, __v_34];
-            record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_90] = [__v_33, __v_34];
+            record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -12164,11 +12325,11 @@ fn aiur_fn_85(
         if (__v_11 != __v_12) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("Lam with zero binders".to_string()) });
         }
-        let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[83].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[83].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[83].bump_multiplicity(__i); } let __ret: [G; OUT_83] = unsafe { *(record.function_queries[83].output_at(__i).as_ptr() as *const [G; OUT_83]) }; __ret }, _ => aiur_fn_83(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_85] = [__v_13, __v_14];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_14];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       9u64 => {
@@ -12178,27 +12339,27 @@ fn aiur_fn_85(
         if (__v_11 != __v_12) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("All with zero binders".to_string()) });
         }
-        let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[84].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[84].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[84].bump_multiplicity(__i); } let __ret: [G; OUT_84] = unsafe { *(record.function_queries[84].output_at(__i).as_ptr() as *const [G; OUT_84]) }; __ret }, _ => aiur_fn_84(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         let __v_14: G = __r_arr[1];
-        let __ret: [G; OUT_85] = [__v_13, __v_14];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_14];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_85] = [__v_11, __v_12];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_11, __v_12];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       11u64 => {
         let __v_11: G = G::from_u64(11);
         let __v_12: G = G::from_u64(0);
         let __v_13: G = { let __values: [G; 18] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_85] = [__v_13, __v_10];
-        record.function_queries[85].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_90] = [__v_13, __v_10];
+        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -12208,15 +12369,15 @@ fn aiur_fn_85(
   })
 }
 
-const INPUT_SIZE_86: usize = 9;
-const IN_86: usize = 9;
-const OUT_86: usize = 2;
-fn aiur_fn_86(
-  inp: [G; IN_86],
+const INPUT_SIZE_91: usize = 9;
+const IN_91: usize = 9;
+const OUT_91: usize = 2;
+fn aiur_fn_91(
+  inp: [G; IN_91],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_86], ExecError> {
+) -> Result<[G; OUT_91], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12227,58 +12388,78 @@ fn aiur_fn_86(
     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_9: G = (__v_7 + __v_8);
+    let __v_10: G = (__v_6 + __v_9);
+    let __v_11: G = (__v_5 + __v_10);
+    let __v_12: G = (__v_4 + __v_11);
+    let __v_13: G = (__v_3 + __v_12);
+    let __v_14: G = (__v_2 + __v_13);
     let __v_15: G = G::from_u64(0);
-    let __v_16: G = G::from_u64(0);
-    let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } };
-    let __v_17: G = __r_arr[0];
+    if (__v_14 != __v_15) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("oversized let flags".to_string()) });
+    }
+    let __v_16: G = G::from_u64(4);
+    let __v_17: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_16) } else { bytes2_less_than_value(__v_1, __v_16, record) };
     let __v_18: G = G::from_u64(1);
-    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 __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[13].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[13].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[13].bump_multiplicity(__i); } let __ret: [G; OUT_13] = unsafe { *(record.function_queries[13].output_at(__i).as_ptr() as *const [G; OUT_13]) }; __ret }, _ => aiur_fn_13(__args, record, io_buffer, __cu)? } };
-    let __v_26: G = __r_arr[0];
-    let __v_27: G = (__v_17 + __v_26);
-    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("invalid let nonDep flag".to_string()) });
+    if (__v_17 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("reserved let flags".to_string()) });
     }
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    let __v_30: G = __r_arr[1];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-    let __v_31: G = __r_arr[0];
-    let __v_32: G = __r_arr[1];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-    let __v_33: G = __r_arr[0];
-    let __v_34: G = __r_arr[1];
-    let __v_35: G = G::from_u64(10);
-    let __v_36: G = G::from_u64(0);
-    let __v_37: G = { let __values: [G; 18] = [__v_35, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29, __v_31, __v_33, __v_36, __v_36, __v_36, __v_36, __v_36, __v_36]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_86] = [__v_37, __v_34];
-    record.function_queries[86].finish(&inp[..], &__ret[..], !unconstrained);
+    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_19: G = __b1_out[0];
+    let __v_20: G = __b1_out[1];
+    let __v_21: G = __b1_out[2];
+    let __v_22: G = __b1_out[3];
+    let __v_23: G = __b1_out[4];
+    let __v_24: G = __b1_out[5];
+    let __v_25: G = __b1_out[6];
+    let __v_26: G = __b1_out[7];
+    let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_20.as_canonical_u64() {
+  0u64 => {
+    let __v_27: G = G::from_u64(0);
+    break '__mc_0 [__v_27];
+  },
+  1u64 => {
+    let __v_27: G = G::from_u64(1);
+    break '__mc_0 [__v_27];
+  },
+  _ => {
+    return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64()));
+  },
+}
+ };
+    let __v_27: G = __mc_out___mc_0[0];
+    let __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[86].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[86].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[86].bump_multiplicity(__i); } let __ret: [G; OUT_86] = unsafe { *(record.function_queries[86].output_at(__i).as_ptr() as *const [G; OUT_86]) }; __ret }, _ => aiur_fn_86(__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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __v_34: G = __r_arr[0];
+    let __v_35: G = __r_arr[1];
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__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(10);
+    let __v_39: G = G::from_u64(0);
+    let __v_40: G = { let __values: [G; 18] = [__v_38, __v_19, __v_27, __v_28, __v_29, __v_30, __v_32, __v_34, __v_36, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_91] = [__v_40, __v_37];
+    record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_87: usize = 17;
-const IN_87: usize = 17;
-const OUT_87: usize = 9;
-fn aiur_fn_87(
-  inp: [G; IN_87],
+const INPUT_SIZE_92: usize = 17;
+const IN_92: usize = 17;
+const OUT_92: usize = 9;
+fn aiur_fn_92(
+  inp: [G; IN_92],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_87], ExecError> {
+) -> Result<[G; OUT_92], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12301,8 +12482,8 @@ fn aiur_fn_87(
     let __v_17: G = __r_arr[0];
     match __v_17.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_92] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -12315,7 +12496,7 @@ fn aiur_fn_87(
         let __v_23: G = __r_arr[5];
         let __v_24: G = __r_arr[6];
         let __v_25: G = __r_arr[7];
-        let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__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];
@@ -12328,8 +12509,8 @@ fn aiur_fn_87(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_87] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
-        record.function_queries[87].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_92] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37];
+        record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -12339,18 +12520,18 @@ fn aiur_fn_87(
   })
 }
 
-const INPUT_SIZE_88: usize = 1;
-const IN_88: usize = 1;
-const OUT_88: usize = 10;
-fn aiur_fn_88(
-  inp: [G; IN_88],
+const INPUT_SIZE_93: usize = 1;
+const IN_93: usize = 1;
+const OUT_93: usize = 10;
+fn aiur_fn_93(
+  inp: [G; IN_93],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_88], ExecError> {
+) -> Result<[G; OUT_93], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[80].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[80].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[80].bump_multiplicity(__i); } let __ret: [G; OUT_80] = unsafe { *(record.function_queries[80].output_at(__i).as_ptr() as *const [G; OUT_80]) }; __ret }, _ => aiur_fn_80(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -12369,12 +12550,12 @@ fn aiur_fn_88(
           1u64 => {
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_88] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
-            record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_93] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10];
+            record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__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];
@@ -12385,7 +12566,7 @@ fn aiur_fn_88(
             let __v_19: G = __r_arr[7];
             let __v_20: G = __r_arr[8];
             let __v_21: G = __r_arr[9];
-            let __r_arr: [G; OUT_87] = { let __args: [G; IN_87] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[87].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[87].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[87].bump_multiplicity(__i); } let __ret: [G; OUT_87] = unsafe { *(record.function_queries[87].output_at(__i).as_ptr() as *const [G; OUT_87]) }; __ret }, _ => aiur_fn_87(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__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];
@@ -12395,8 +12576,8 @@ fn aiur_fn_88(
             let __v_28: G = __r_arr[6];
             let __v_29: G = __r_arr[7];
             let __v_30: G = __r_arr[8];
-            let __ret: [G; OUT_88] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
-            record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_93] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21];
+            record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -12405,7 +12586,7 @@ fn aiur_fn_88(
         }
       },
       1u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__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];
@@ -12416,7 +12597,7 @@ fn aiur_fn_88(
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
         let __v_20: G = __r_arr[9];
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__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];
@@ -12431,12 +12612,12 @@ fn aiur_fn_88(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_34: G = G::from_u64(0);
-        let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_93] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__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];
@@ -12447,7 +12628,7 @@ fn aiur_fn_88(
         let __v_18: G = __r_arr[7];
         let __v_19: G = __r_arr[8];
         let __v_20: G = __r_arr[9];
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__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];
@@ -12462,14 +12643,14 @@ fn aiur_fn_88(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_34: G = G::from_u64(0);
-        let __ret: [G; OUT_88] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
-        record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_93] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30];
+        record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_11: G = G::from_u64(4);
-        let __ret: [G; OUT_88] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[88].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_93] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -12479,15 +12660,15 @@ fn aiur_fn_88(
   })
 }
 
-const INPUT_SIZE_89: usize = 1;
-const IN_89: usize = 1;
-const OUT_89: usize = 2;
-fn aiur_fn_89(
-  inp: [G; IN_89],
+const INPUT_SIZE_94: usize = 1;
+const IN_94: usize = 1;
+const OUT_94: usize = 2;
+fn aiur_fn_94(
+  inp: [G; IN_94],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_89], ExecError> {
+) -> Result<[G; OUT_94], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -12683,8 +12864,8 @@ fn aiur_fn_89(
                                                                                                                                 match __v_94.as_canonical_u64() {
                                                                                                                                   0u64 => {
                                                                                                                                     let __v_97: G = { let __values: [G; 32] = [__v_2, __v_5, __v_8, __v_11, __v_14, __v_17, __v_20, __v_23, __v_26, __v_29, __v_32, __v_35, __v_38, __v_41, __v_44, __v_47, __v_50, __v_53, __v_56, __v_59, __v_62, __v_65, __v_68, __v_71, __v_74, __v_77, __v_80, __v_83, __v_86, __v_89, __v_92, __v_95]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                                                                                                    let __ret: [G; OUT_89] = [__v_97, __v_96];
-                                                                                                                                    record.function_queries[89].finish(&inp[..], &__ret[..], !unconstrained);
+                                                                                                                                    let __ret: [G; OUT_94] = [__v_97, __v_96];
+                                                                                                                                    record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained);
                                                                                                                                     return Ok(__ret);
                                                                                                                                   },
                                                                                                                                   _ => {
@@ -12849,15 +13030,15 @@ fn aiur_fn_89(
   })
 }
 
-const INPUT_SIZE_90: usize = 9;
-const IN_90: usize = 9;
-const OUT_90: usize = 2;
-fn aiur_fn_90(
-  inp: [G; IN_90],
+const INPUT_SIZE_95: usize = 9;
+const IN_95: usize = 9;
+const OUT_95: usize = 2;
+fn aiur_fn_95(
+  inp: [G; IN_95],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_90], ExecError> {
+) -> Result<[G; OUT_95], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12875,12 +13056,12 @@ fn aiur_fn_90(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_12, __v_0];
-        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_95] = [__v_12, __v_0];
+        record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
@@ -12892,13 +13073,13 @@ fn aiur_fn_90(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_90] = [__v_23, __v_21];
-        record.function_queries[90].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_95] = [__v_23, __v_21];
+        record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -12908,15 +13089,15 @@ fn aiur_fn_90(
   })
 }
 
-const INPUT_SIZE_91: usize = 9;
-const IN_91: usize = 9;
-const OUT_91: usize = 2;
-fn aiur_fn_91(
-  inp: [G; IN_91],
+const INPUT_SIZE_96: usize = 9;
+const IN_96: usize = 9;
+const OUT_96: usize = 2;
+fn aiur_fn_96(
+  inp: [G; IN_96],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_91], ExecError> {
+) -> Result<[G; OUT_96], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -12934,12 +13115,12 @@ fn aiur_fn_91(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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];
-        record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_96] = [__v_12, __v_0];
+        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[88].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[88].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[88].bump_multiplicity(__i); } let __ret: [G; OUT_88] = unsafe { *(record.function_queries[88].output_at(__i).as_ptr() as *const [G; OUT_88]) }; __ret }, _ => aiur_fn_88(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[93].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[93].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[93].bump_multiplicity(__i); } let __ret: [G; OUT_93] = unsafe { *(record.function_queries[93].output_at(__i).as_ptr() as *const [G; OUT_93]) }; __ret }, _ => aiur_fn_93(__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];
@@ -12959,14 +13140,14 @@ fn aiur_fn_91(
         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_91] = { let __args: [G; IN_91] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_29];
-        record.function_queries[91].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_96] = [__v_32, __v_29];
+        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -12976,15 +13157,15 @@ fn aiur_fn_91(
   })
 }
 
-const INPUT_SIZE_92: usize = 9;
-const IN_92: usize = 9;
-const OUT_92: usize = 2;
-fn aiur_fn_92(
-  inp: [G; IN_92],
+const INPUT_SIZE_97: usize = 9;
+const IN_97: usize = 9;
+const OUT_97: usize = 2;
+fn aiur_fn_97(
+  inp: [G; IN_97],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_92], ExecError> {
+) -> Result<[G; OUT_97], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13002,12 +13183,12 @@ fn aiur_fn_92(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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, __v_0];
-        record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_97] = [__v_12, __v_0];
+        record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
@@ -13019,13 +13200,13 @@ fn aiur_fn_92(
         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_92] = { let __args: [G; IN_92] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_92] = [__v_23, __v_21];
-        record.function_queries[92].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_97] = [__v_23, __v_21];
+        record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -13035,18 +13216,18 @@ fn aiur_fn_92(
   })
 }
 
-const INPUT_SIZE_93: usize = 1;
-const IN_93: usize = 1;
-const OUT_93: usize = 2;
-fn aiur_fn_93(
-  inp: [G; IN_93],
+const INPUT_SIZE_98: usize = 1;
+const IN_98: usize = 1;
+const OUT_98: usize = 2;
+fn aiur_fn_98(
+  inp: [G; IN_98],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_93], ExecError> {
+) -> Result<[G; OUT_98], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13056,27 +13237,27 @@ fn aiur_fn_93(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_93] = [__v_10, __v_11];
-    record.function_queries[93].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_98] = [__v_10, __v_11];
+    record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_94: usize = 1;
-const IN_94: usize = 1;
-const OUT_94: usize = 2;
-fn aiur_fn_94(
-  inp: [G; IN_94],
+const INPUT_SIZE_99: usize = 1;
+const IN_99: usize = 1;
+const OUT_99: usize = 2;
+fn aiur_fn_99(
+  inp: [G; IN_99],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_94], ExecError> {
+) -> Result<[G; OUT_99], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13086,27 +13267,27 @@ fn aiur_fn_94(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_94] = [__v_10, __v_11];
-    record.function_queries[94].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_99] = [__v_10, __v_11];
+    record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_95: usize = 1;
-const IN_95: usize = 1;
-const OUT_95: usize = 2;
-fn aiur_fn_95(
-  inp: [G; IN_95],
+const INPUT_SIZE_100: usize = 1;
+const IN_100: usize = 1;
+const OUT_100: usize = 2;
+fn aiur_fn_100(
+  inp: [G; IN_100],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_95], ExecError> {
+) -> Result<[G; OUT_100], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13116,88 +13297,88 @@ fn aiur_fn_95(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_95] = [__v_10, __v_11];
-    record.function_queries[95].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_100] = [__v_10, __v_11];
+    record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_96: usize = 1;
-const IN_96: usize = 1;
-const OUT_96: usize = 2;
-fn aiur_fn_96(
-  inp: [G; IN_96],
+const INPUT_SIZE_101: usize = 1;
+const IN_101: usize = 1;
+const OUT_101: usize = 2;
+fn aiur_fn_101(
+  inp: [G; IN_101],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_96], ExecError> {
+) -> Result<[G; OUT_101], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(0);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       9u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(1);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       10u64 => {
         let __v_1: G = G::from_u64(2);
         let __v_2: G = G::from_u64(2);
-        let __ret: [G; OUT_96] = [__v_1, __v_2];
-        record.function_queries[96].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_101] = [__v_1, __v_2];
+        record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -13207,24 +13388,24 @@ fn aiur_fn_96(
   })
 }
 
-const INPUT_SIZE_97: usize = 1;
-const IN_97: usize = 1;
-const OUT_97: usize = 13;
-fn aiur_fn_97(
-  inp: [G; IN_97],
+const INPUT_SIZE_102: usize = 1;
+const IN_102: usize = 1;
+const OUT_102: usize = 13;
+fn aiur_fn_102(
+  inp: [G; IN_102],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_97], ExecError> {
+) -> Result<[G; OUT_102], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -13234,30 +13415,30 @@ fn aiur_fn_97(
     let __v_11: G = __r_arr[6];
     let __v_12: G = __r_arr[7];
     let __v_13: G = __r_arr[8];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __v_15: G = __r_arr[1];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = __r_arr[1];
-    let __ret: [G; OUT_97] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
-    record.function_queries[97].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_102] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_16, __v_17];
+    record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_98: usize = 1;
-const IN_98: usize = 1;
-const OUT_98: usize = 10;
-fn aiur_fn_98(
-  inp: [G; IN_98],
+const INPUT_SIZE_103: usize = 1;
+const IN_103: usize = 1;
+const OUT_103: usize = 10;
+fn aiur_fn_103(
+  inp: [G; IN_103],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_98], ExecError> {
+) -> Result<[G; OUT_103], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13267,24 +13448,24 @@ fn aiur_fn_98(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_98] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[98].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_103] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_99: usize = 9;
-const IN_99: usize = 9;
-const OUT_99: usize = 2;
-fn aiur_fn_99(
-  inp: [G; IN_99],
+const INPUT_SIZE_104: usize = 9;
+const IN_104: usize = 9;
+const OUT_104: usize = 2;
+fn aiur_fn_104(
+  inp: [G; IN_104],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_99], ExecError> {
+) -> Result<[G; OUT_104], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13302,12 +13483,12 @@ fn aiur_fn_99(
         let __v_10: G = G::from_u64(1);
         let __v_11: G = G::from_u64(1);
         let __v_12: G = { let __values: [G; 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_99] = [__v_12, __v_0];
-        record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_104] = [__v_12, __v_0];
+        record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -13317,7 +13498,7 @@ fn aiur_fn_99(
         let __v_16: G = __r_arr[6];
         let __v_17: G = __r_arr[7];
         let __v_18: G = __r_arr[8];
-        let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[16].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[16].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[16].bump_multiplicity(__i); } let __ret: [G; OUT_16] = unsafe { *(record.function_queries[16].output_at(__i).as_ptr() as *const [G; OUT_16]) }; __ret }, _ => aiur_fn_16(__args, record, io_buffer, __cu)? } };
@@ -13329,13 +13510,13 @@ fn aiur_fn_99(
         let __v_26: G = __r_arr[5];
         let __v_27: G = __r_arr[6];
         let __v_28: G = __r_arr[7];
-        let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_99] = [__v_32, __v_30];
-        record.function_queries[99].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_104] = [__v_32, __v_30];
+        record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -13345,110 +13526,116 @@ fn aiur_fn_99(
   })
 }
 
-const INPUT_SIZE_100: usize = 1;
-const IN_100: usize = 1;
-const OUT_100: usize = 45;
-fn aiur_fn_100(
-  inp: [G; IN_100],
+const INPUT_SIZE_105: usize = 1;
+const IN_105: usize = 1;
+const OUT_105: usize = 45;
+fn aiur_fn_105(
+  inp: [G; IN_105],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_100], ExecError> {
+) -> Result<[G; OUT_105], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
+    let __v_3: G = G::from_u64(4);
+    let __v_4: G = if unconstrained { Bytes2::less_than(&__v_1, &__v_3) } else { bytes2_less_than_value(__v_1, __v_3, record) };
+    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("invalid recursor flags".to_string()) });
+    }
     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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_11: G = __r_arr[0];
-    let __v_12: G = __r_arr[1];
-    let __v_13: G = __r_arr[2];
-    let __v_14: G = __r_arr[3];
-    let __v_15: G = __r_arr[4];
-    let __v_16: G = __r_arr[5];
-    let __v_17: G = __r_arr[6];
-    let __v_18: G = __r_arr[7];
-    let __v_19: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_20: G = __r_arr[0];
-    let __v_21: G = __r_arr[1];
-    let __v_22: G = __r_arr[2];
-    let __v_23: G = __r_arr[3];
-    let __v_24: G = __r_arr[4];
-    let __v_25: G = __r_arr[5];
-    let __v_26: G = __r_arr[6];
-    let __v_27: G = __r_arr[7];
-    let __v_28: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_29: G = __r_arr[0];
-    let __v_30: G = __r_arr[1];
-    let __v_31: G = __r_arr[2];
-    let __v_32: G = __r_arr[3];
-    let __v_33: G = __r_arr[4];
-    let __v_34: G = __r_arr[5];
-    let __v_35: G = __r_arr[6];
-    let __v_36: G = __r_arr[7];
-    let __v_37: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_38: G = __r_arr[0];
-    let __v_39: G = __r_arr[1];
-    let __v_40: G = __r_arr[2];
-    let __v_41: G = __r_arr[3];
-    let __v_42: G = __r_arr[4];
-    let __v_43: G = __r_arr[5];
-    let __v_44: G = __r_arr[6];
-    let __v_45: G = __r_arr[7];
-    let __v_46: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_47: G = __r_arr[0];
-    let __v_48: G = __r_arr[1];
-    let __v_49: G = __r_arr[2];
-    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 __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
-    let __v_56: G = __r_arr[0];
-    let __v_57: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_57]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
-    let __v_58: G = __r_arr[0];
-    let __v_59: G = __r_arr[1];
-    let __v_60: G = __r_arr[2];
-    let __v_61: G = __r_arr[3];
-    let __v_62: G = __r_arr[4];
-    let __v_63: G = __r_arr[5];
-    let __v_64: G = __r_arr[6];
-    let __v_65: G = __r_arr[7];
-    let __v_66: G = __r_arr[8];
-    let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_66, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[99].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[99].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[99].bump_multiplicity(__i); } let __ret: [G; OUT_99] = unsafe { *(record.function_queries[99].output_at(__i).as_ptr() as *const [G; OUT_99]) }; __ret }, _ => aiur_fn_99(__args, record, io_buffer, __cu)? } };
-    let __v_67: G = __r_arr[0];
-    let __v_68: G = __r_arr[1];
-    let __ret: [G; OUT_100] = [__v_3, __v_4, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_56, __v_67, __v_68];
-    record.function_queries[100].finish(&inp[..], &__ret[..], !unconstrained);
+    let __v_6: G = __b1_out[0];
+    let __v_7: G = __b1_out[1];
+    let __v_8: G = __b1_out[2];
+    let __v_9: G = __b1_out[3];
+    let __v_10: G = __b1_out[4];
+    let __v_11: G = __b1_out[5];
+    let __v_12: G = __b1_out[6];
+    let __v_13: G = __b1_out[7];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __v_14: G = __r_arr[0];
+    let __v_15: G = __r_arr[1];
+    let __v_16: G = __r_arr[2];
+    let __v_17: G = __r_arr[3];
+    let __v_18: G = __r_arr[4];
+    let __v_19: G = __r_arr[5];
+    let __v_20: G = __r_arr[6];
+    let __v_21: G = __r_arr[7];
+    let __v_22: G = __r_arr[8];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __v_32: G = __r_arr[0];
+    let __v_33: G = __r_arr[1];
+    let __v_34: G = __r_arr[2];
+    let __v_35: G = __r_arr[3];
+    let __v_36: G = __r_arr[4];
+    let __v_37: G = __r_arr[5];
+    let __v_38: G = __r_arr[6];
+    let __v_39: G = __r_arr[7];
+    let __v_40: G = __r_arr[8];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __v_41: G = __r_arr[0];
+    let __v_42: G = __r_arr[1];
+    let __v_43: G = __r_arr[2];
+    let __v_44: G = __r_arr[3];
+    let __v_45: G = __r_arr[4];
+    let __v_46: G = __r_arr[5];
+    let __v_47: G = __r_arr[6];
+    let __v_48: G = __r_arr[7];
+    let __v_49: G = __r_arr[8];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_49]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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 __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_58]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __v_59: G = __r_arr[0];
+    let __v_60: G = __r_arr[1];
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_60]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
+    let __v_61: G = __r_arr[0];
+    let __v_62: G = __r_arr[1];
+    let __v_63: G = __r_arr[2];
+    let __v_64: G = __r_arr[3];
+    let __v_65: G = __r_arr[4];
+    let __v_66: G = __r_arr[5];
+    let __v_67: G = __r_arr[6];
+    let __v_68: G = __r_arr[7];
+    let __v_69: G = __r_arr[8];
+    let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_69, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } };
+    let __v_70: G = __r_arr[0];
+    let __v_71: G = __r_arr[1];
+    let __ret: [G; OUT_105] = [__v_6, __v_7, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __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_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_59, __v_70, __v_71];
+    record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_101: usize = 1;
-const IN_101: usize = 1;
-const OUT_101: usize = 0;
-fn aiur_fn_101(
-  inp: [G; IN_101],
+const INPUT_SIZE_106: usize = 1;
+const IN_106: usize = 1;
+const OUT_106: usize = 0;
+fn aiur_fn_106(
+  inp: [G; IN_106],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_101], ExecError> {
+) -> Result<[G; OUT_106], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(2);
@@ -13457,28 +13644,28 @@ fn aiur_fn_101(
     if (__v_2 != __v_3) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("Bool byte is not 0 or 1".to_string()) });
     }
-    let __ret: [G; OUT_101] = [];
-    record.function_queries[101].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_106] = [];
+    record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_102: usize = 1;
-const IN_102: usize = 1;
-const OUT_102: usize = 11;
-fn aiur_fn_102(
-  inp: [G; IN_102],
+const INPUT_SIZE_107: usize = 1;
+const IN_107: usize = 1;
+const OUT_107: usize = 11;
+fn aiur_fn_107(
+  inp: [G; IN_107],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_102], ExecError> {
+) -> Result<[G; OUT_107], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -13488,49 +13675,49 @@ fn aiur_fn_102(
     let __v_9: G = __r_arr[6];
     let __v_10: G = __r_arr[7];
     let __v_11: G = __r_arr[8];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
-    let __ret: [G; OUT_102] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
-    record.function_queries[102].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_107] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13];
+    record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_103: usize = 1;
-const IN_103: usize = 1;
-const OUT_103: usize = 1;
-fn aiur_fn_103(
-  inp: [G; IN_103],
+const INPUT_SIZE_108: usize = 1;
+const IN_108: usize = 1;
+const OUT_108: usize = 1;
+fn aiur_fn_108(
+  inp: [G; IN_108],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_103], ExecError> {
+) -> Result<[G; OUT_108], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_103] = [__v_1];
-        record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_108] = [__v_1];
+        record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_103] = [__v_1];
-        record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_108] = [__v_1];
+        record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_103] = [__v_1];
-        record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_108] = [__v_1];
+        record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_1: G = G::from_u64(3);
-        let __ret: [G; OUT_103] = [__v_1];
-        record.function_queries[103].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_108] = [__v_1];
+        record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -13540,23 +13727,23 @@ fn aiur_fn_103(
   })
 }
 
-const INPUT_SIZE_104: usize = 1;
-const IN_104: usize = 1;
-const OUT_104: usize = 11;
-fn aiur_fn_104(
-  inp: [G; IN_104],
+const INPUT_SIZE_109: usize = 1;
+const IN_109: usize = 1;
+const OUT_109: usize = 11;
+fn aiur_fn_109(
+  inp: [G; IN_109],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_104], ExecError> {
+) -> Result<[G; OUT_109], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -13566,31 +13753,31 @@ fn aiur_fn_104(
     let __v_10: G = __r_arr[6];
     let __v_11: G = __r_arr[7];
     let __v_12: G = __r_arr[8];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = __r_arr[1];
-    let __ret: [G; OUT_104] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
-    record.function_queries[104].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_109] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_13, __v_14];
+    record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_105: usize = 1;
-const IN_105: usize = 1;
-const OUT_105: usize = 35;
-fn aiur_fn_105(
-  inp: [G; IN_105],
+const INPUT_SIZE_110: usize = 1;
+const IN_110: usize = 1;
+const OUT_110: usize = 35;
+fn aiur_fn_110(
+  inp: [G; IN_110],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_105], ExecError> {
+) -> Result<[G; OUT_110], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[101].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[101].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[101].bump_multiplicity(__i); } let __ret: [G; OUT_101] = unsafe { *(record.function_queries[101].output_at(__i).as_ptr() as *const [G; OUT_101]) }; __ret }, _ => aiur_fn_101(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -13600,7 +13787,7 @@ fn aiur_fn_105(
     let __v_9: G = __r_arr[6];
     let __v_10: G = __r_arr[7];
     let __v_11: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -13610,7 +13797,7 @@ fn aiur_fn_105(
     let __v_18: G = __r_arr[6];
     let __v_19: G = __r_arr[7];
     let __v_20: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -13620,7 +13807,7 @@ fn aiur_fn_105(
     let __v_27: G = __r_arr[6];
     let __v_28: G = __r_arr[7];
     let __v_29: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
     let __v_31: G = __r_arr[1];
     let __v_32: G = __r_arr[2];
@@ -13630,24 +13817,24 @@ fn aiur_fn_105(
     let __v_36: G = __r_arr[6];
     let __v_37: G = __r_arr[7];
     let __v_38: G = __r_arr[8];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_38]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_39: G = __r_arr[0];
     let __v_40: G = __r_arr[1];
-    let __ret: [G; OUT_105] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40];
-    record.function_queries[105].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_110] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_39, __v_40];
+    record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_106: usize = 9;
-const IN_106: usize = 9;
-const OUT_106: usize = 2;
-fn aiur_fn_106(
-  inp: [G; IN_106],
+const INPUT_SIZE_111: usize = 9;
+const IN_111: usize = 9;
+const OUT_111: usize = 2;
+fn aiur_fn_111(
+  inp: [G; IN_111],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_106], ExecError> {
+) -> Result<[G; OUT_111], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -13665,12 +13852,12 @@ fn aiur_fn_106(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_106] = [__v_12, __v_0];
-        record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_111] = [__v_12, __v_0];
+        record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__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];
@@ -13715,13 +13902,13 @@ fn aiur_fn_106(
         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_106] = { let __args: [G; IN_106] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } };
         let __v_53: G = __r_arr[0];
         let __v_54: G = __r_arr[1];
         let __v_55: G = 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_106] = [__v_56, __v_54];
-        record.function_queries[106].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_111] = [__v_56, __v_54];
+        record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -13731,20 +13918,21 @@ fn aiur_fn_106(
   })
 }
 
-const INPUT_SIZE_107: usize = 1;
-const IN_107: usize = 1;
-const OUT_107: usize = 28;
-fn aiur_fn_107(
-  inp: [G; IN_107],
+const INPUT_SIZE_112: usize = 1;
+const IN_112: usize = 1;
+const OUT_112: usize = 28;
+fn aiur_fn_112(
+  inp: [G; IN_112],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_107], ExecError> {
+) -> Result<[G; OUT_112], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
+    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } };
     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];
@@ -13754,7 +13942,7 @@ fn aiur_fn_107(
     let __v_8: G = __b1_out[5];
     let __v_9: G = __b1_out[6];
     let __v_10: G = __b1_out[7];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = __r_arr[2];
@@ -13764,7 +13952,7 @@ fn aiur_fn_107(
     let __v_17: G = __r_arr[6];
     let __v_18: G = __r_arr[7];
     let __v_19: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
     let __v_21: G = __r_arr[1];
     let __v_22: G = __r_arr[2];
@@ -13774,7 +13962,7 @@ fn aiur_fn_107(
     let __v_26: G = __r_arr[6];
     let __v_27: G = __r_arr[7];
     let __v_28: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
     let __v_30: G = __r_arr[1];
     let __v_31: G = __r_arr[2];
@@ -13784,10 +13972,10 @@ fn aiur_fn_107(
     let __v_35: G = __r_arr[6];
     let __v_36: G = __r_arr[7];
     let __v_37: G = __r_arr[8];
-    let __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[85].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[85].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[85].bump_multiplicity(__i); } let __ret: [G; OUT_85] = unsafe { *(record.function_queries[85].output_at(__i).as_ptr() as *const [G; OUT_85]) }; __ret }, _ => aiur_fn_85(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
     let __v_38: G = __r_arr[0];
     let __v_39: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_39]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -13797,27 +13985,27 @@ fn aiur_fn_107(
     let __v_46: G = __r_arr[6];
     let __v_47: G = __r_arr[7];
     let __v_48: G = __r_arr[8];
-    let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[106].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[106].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[106].bump_multiplicity(__i); } let __ret: [G; OUT_106] = unsafe { *(record.function_queries[106].output_at(__i).as_ptr() as *const [G; OUT_106]) }; __ret }, _ => aiur_fn_106(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_48, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
     let __v_50: G = __r_arr[1];
-    let __ret: [G; OUT_107] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50];
-    record.function_queries[107].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_112] = [__v_3, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_49, __v_50];
+    record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_108: usize = 1;
-const IN_108: usize = 1;
-const OUT_108: usize = 10;
-fn aiur_fn_108(
-  inp: [G; IN_108],
+const INPUT_SIZE_113: usize = 1;
+const IN_113: usize = 1;
+const OUT_113: usize = 10;
+fn aiur_fn_113(
+  inp: [G; IN_113],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_108], ExecError> {
+) -> Result<[G; OUT_113], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13827,27 +14015,27 @@ fn aiur_fn_108(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
-    let __ret: [G; OUT_108] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
-    record.function_queries[108].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_113] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11];
+    record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_109: usize = 1;
-const IN_109: usize = 1;
-const OUT_109: usize = 18;
-fn aiur_fn_109(
-  inp: [G; IN_109],
+const INPUT_SIZE_114: usize = 1;
+const IN_114: usize = 1;
+const OUT_114: usize = 18;
+fn aiur_fn_114(
+  inp: [G; IN_114],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_109], ExecError> {
+) -> Result<[G; OUT_114], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -13857,7 +14045,7 @@ fn aiur_fn_109(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
@@ -13867,32 +14055,32 @@ fn aiur_fn_109(
     let __v_16: G = __r_arr[6];
     let __v_17: G = __r_arr[7];
     let __v_18: G = __r_arr[8];
-    let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __v_20: G = __r_arr[1];
-    let __ret: [G; OUT_109] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20];
-    record.function_queries[109].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_114] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20];
+    record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_110: usize = 1;
-const IN_110: usize = 1;
-const OUT_110: usize = 46;
-fn aiur_fn_110(
-  inp: [G; IN_110],
+const INPUT_SIZE_115: usize = 1;
+const IN_115: usize = 1;
+const OUT_115: usize = 46;
+fn aiur_fn_115(
+  inp: [G; IN_115],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_110], ExecError> {
+) -> Result<[G; OUT_115], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__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];
@@ -13908,12 +14096,12 @@ fn aiur_fn_110(
         let __v_15: G = __r_arr[12];
         let __v_16: G = G::from_u64(0);
         let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_110] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15];
-        record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_115] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15];
+        record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__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];
@@ -13944,12 +14132,12 @@ fn aiur_fn_110(
         let __v_30: G = __r_arr[27];
         let __v_31: G = G::from_u64(1);
         let __v_32: G = G::from_u64(0);
-        let __ret: [G; OUT_110] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
-        record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_115] = [__v_31, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_32, __v_30];
+        record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__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];
@@ -13996,8 +14184,8 @@ fn aiur_fn_110(
         let __v_46: G = __r_arr[43];
         let __v_47: G = __r_arr[44];
         let __v_48: G = G::from_u64(2);
-        let __ret: [G; OUT_110] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
-        record.function_queries[110].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_115] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
+        record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -14007,15 +14195,15 @@ fn aiur_fn_110(
   })
 }
 
-const INPUT_SIZE_111: usize = 9;
-const IN_111: usize = 9;
-const OUT_111: usize = 2;
-fn aiur_fn_111(
-  inp: [G; IN_111],
+const INPUT_SIZE_116: usize = 9;
+const IN_116: usize = 9;
+const OUT_116: usize = 2;
+fn aiur_fn_116(
+  inp: [G; IN_116],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_111], ExecError> {
+) -> Result<[G; OUT_116], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14033,12 +14221,12 @@ fn aiur_fn_111(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_111] = [__v_12, __v_0];
-        record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_116] = [__v_12, __v_0];
+        record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[110].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[110].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[110].bump_multiplicity(__i); } let __ret: [G; OUT_110] = unsafe { *(record.function_queries[110].output_at(__i).as_ptr() as *const [G; OUT_110]) }; __ret }, _ => aiur_fn_110(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = __r_arr[2];
@@ -14094,13 +14282,13 @@ fn aiur_fn_111(
         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_111] = { let __args: [G; IN_111] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_111] = [__v_67, __v_65];
-        record.function_queries[111].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_116] = [__v_67, __v_65];
+        record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -14110,21 +14298,21 @@ fn aiur_fn_111(
   })
 }
 
-const INPUT_SIZE_112: usize = 2;
-const IN_112: usize = 2;
-const OUT_112: usize = 46;
-fn aiur_fn_112(
-  inp: [G; IN_112],
+const INPUT_SIZE_117: usize = 2;
+const IN_117: usize = 2;
+const OUT_117: usize = 46;
+fn aiur_fn_117(
+  inp: [G; IN_117],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_112], ExecError> {
+) -> Result<[G; OUT_117], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__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];
@@ -14140,12 +14328,12 @@ fn aiur_fn_112(
         let __v_14: G = __r_arr[12];
         let __v_15: G = G::from_u64(0);
         let __v_16: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[100].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[100].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[100].bump_multiplicity(__i); } let __ret: [G; OUT_100] = unsafe { *(record.function_queries[100].output_at(__i).as_ptr() as *const [G; OUT_100]) }; __ret }, _ => aiur_fn_100(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[105].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[105].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[105].bump_multiplicity(__i); } let __ret: [G; OUT_105] = unsafe { *(record.function_queries[105].output_at(__i).as_ptr() as *const [G; OUT_105]) }; __ret }, _ => aiur_fn_105(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -14192,12 +14380,12 @@ fn aiur_fn_112(
         let __v_45: G = __r_arr[43];
         let __v_46: G = __r_arr[44];
         let __v_47: G = G::from_u64(1);
-        let __ret: [G; OUT_112] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_102] = { let __args: [G; IN_102] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[102].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[102].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[102].bump_multiplicity(__i); } let __ret: [G; OUT_102] = unsafe { *(record.function_queries[102].output_at(__i).as_ptr() as *const [G; OUT_102]) }; __ret }, _ => aiur_fn_102(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[107].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[107].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[107].bump_multiplicity(__i); } let __ret: [G; OUT_107] = unsafe { *(record.function_queries[107].output_at(__i).as_ptr() as *const [G; OUT_107]) }; __ret }, _ => aiur_fn_107(__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];
@@ -14211,12 +14399,12 @@ fn aiur_fn_112(
         let __v_12: G = __r_arr[10];
         let __v_13: G = G::from_u64(2);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_104] = { let __args: [G; IN_104] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[104].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[104].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[104].bump_multiplicity(__i); } let __ret: [G; OUT_104] = unsafe { *(record.function_queries[104].output_at(__i).as_ptr() as *const [G; OUT_104]) }; __ret }, _ => aiur_fn_104(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__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];
@@ -14230,12 +14418,12 @@ fn aiur_fn_112(
         let __v_12: G = __r_arr[10];
         let __v_13: G = G::from_u64(3);
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__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];
@@ -14256,12 +14444,12 @@ fn aiur_fn_112(
         let __v_19: G = __r_arr[17];
         let __v_20: G = G::from_u64(4);
         let __v_21: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__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];
@@ -14274,12 +14462,12 @@ fn aiur_fn_112(
         let __v_11: G = __r_arr[9];
         let __v_12: G = G::from_u64(5);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__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];
@@ -14292,12 +14480,12 @@ fn aiur_fn_112(
         let __v_11: G = __r_arr[9];
         let __v_12: G = G::from_u64(6);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_113] = { let __args: [G; IN_113] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[113].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[113].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[113].bump_multiplicity(__i); } let __ret: [G; OUT_113] = unsafe { *(record.function_queries[113].output_at(__i).as_ptr() as *const [G; OUT_113]) }; __ret }, _ => aiur_fn_113(__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];
@@ -14310,8 +14498,8 @@ fn aiur_fn_112(
         let __v_11: G = __r_arr[9];
         let __v_12: G = G::from_u64(7);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_112] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[112].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_117] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -14321,15 +14509,15 @@ fn aiur_fn_112(
   })
 }
 
-const INPUT_SIZE_113: usize = 10;
-const IN_113: usize = 10;
-const OUT_113: usize = 46;
-fn aiur_fn_113(
-  inp: [G; IN_113],
+const INPUT_SIZE_118: usize = 10;
+const IN_118: usize = 10;
+const OUT_118: usize = 46;
+fn aiur_fn_118(
+  inp: [G; IN_118],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_113], ExecError> {
+) -> Result<[G; OUT_118], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14343,13 +14531,13 @@ fn aiur_fn_113(
     let __v_9: G = inp[9];
     match __v_0.as_canonical_u64() {
       12u64 => {
-        let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         let __v_12: G = G::from_u64(8);
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_113] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
-        record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_118] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11];
+        record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       13u64 => {
@@ -14363,7 +14551,7 @@ fn aiur_fn_113(
         if (__v_15 != __v_16) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) });
         }
-        let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__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];
@@ -14410,8 +14598,8 @@ fn aiur_fn_113(
         let __v_60: G = __r_arr[43];
         let __v_61: G = __r_arr[44];
         let __v_62: G = __r_arr[45];
-        let __ret: [G; OUT_113] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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];
-        record.function_queries[113].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_118] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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];
+        record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -14421,18 +14609,18 @@ fn aiur_fn_113(
   })
 }
 
-const INPUT_SIZE_114: usize = 1;
-const IN_114: usize = 1;
-const OUT_114: usize = 49;
-fn aiur_fn_114(
-  inp: [G; IN_114],
+const INPUT_SIZE_119: usize = 1;
+const IN_119: usize = 1;
+const OUT_119: usize = 49;
+fn aiur_fn_119(
+  inp: [G; IN_119],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_114], ExecError> {
+) -> Result<[G; OUT_119], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -14445,7 +14633,7 @@ fn aiur_fn_114(
     let __v_10: G = __r_arr[9];
     let __mc_out___mc_0: [G; 46] = '__mc_0: { match __v_1.as_canonical_u64() {
   12u64 => {
-    let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[111].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[111].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[111].bump_multiplicity(__i); } let __ret: [G; OUT_111] = unsafe { *(record.function_queries[111].output_at(__i).as_ptr() as *const [G; OUT_111]) }; __ret }, _ => aiur_fn_111(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
     let __v_13: G = G::from_u64(8);
@@ -14463,7 +14651,7 @@ fn aiur_fn_114(
     if (__v_16 != __v_17) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("constant info: tag4 size exceeds a single byte".to_string()) });
     }
-    let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[112].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[112].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[112].bump_multiplicity(__i); } let __ret: [G; OUT_112] = unsafe { *(record.function_queries[112].output_at(__i).as_ptr() as *const [G; OUT_112]) }; __ret }, _ => aiur_fn_112(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__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];
@@ -14563,7 +14751,7 @@ fn aiur_fn_114(
     let __v_54: G = __mc_out___mc_0[43];
     let __v_55: G = __mc_out___mc_0[44];
     let __v_56: G = __mc_out___mc_0[45];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -14573,10 +14761,10 @@ fn aiur_fn_114(
     let __v_63: G = __r_arr[6];
     let __v_64: G = __r_arr[7];
     let __v_65: G = __r_arr[8];
-    let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[90].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[90].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[90].bump_multiplicity(__i); } let __ret: [G; OUT_90] = unsafe { *(record.function_queries[90].output_at(__i).as_ptr() as *const [G; OUT_90]) }; __ret }, _ => aiur_fn_90(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_65, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[95].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[95].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[95].bump_multiplicity(__i); } let __ret: [G; OUT_95] = unsafe { *(record.function_queries[95].output_at(__i).as_ptr() as *const [G; OUT_95]) }; __ret }, _ => aiur_fn_95(__args, record, io_buffer, __cu)? } };
     let __v_66: G = __r_arr[0];
     let __v_67: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_67]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__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];
@@ -14586,10 +14774,10 @@ fn aiur_fn_114(
     let __v_74: G = __r_arr[6];
     let __v_75: G = __r_arr[7];
     let __v_76: G = __r_arr[8];
-    let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[92].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[92].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[92].bump_multiplicity(__i); } let __ret: [G; OUT_92] = unsafe { *(record.function_queries[92].output_at(__i).as_ptr() as *const [G; OUT_92]) }; __ret }, _ => aiur_fn_92(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_76, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[97].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[97].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[97].bump_multiplicity(__i); } let __ret: [G; OUT_97] = unsafe { *(record.function_queries[97].output_at(__i).as_ptr() as *const [G; OUT_97]) }; __ret }, _ => aiur_fn_97(__args, record, io_buffer, __cu)? } };
     let __v_77: G = __r_arr[0];
     let __v_78: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_78]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_78]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_79: G = __r_arr[0];
     let __v_80: G = __r_arr[1];
     let __v_81: G = __r_arr[2];
@@ -14599,24 +14787,24 @@ fn aiur_fn_114(
     let __v_85: G = __r_arr[6];
     let __v_86: G = __r_arr[7];
     let __v_87: G = __r_arr[8];
-    let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[91].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[91].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[91].bump_multiplicity(__i); } let __ret: [G; OUT_91] = unsafe { *(record.function_queries[91].output_at(__i).as_ptr() as *const [G; OUT_91]) }; __ret }, _ => aiur_fn_91(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_96] = { let __args: [G; IN_96] = [__v_87, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[96].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[96].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[96].bump_multiplicity(__i); } let __ret: [G; OUT_96] = unsafe { *(record.function_queries[96].output_at(__i).as_ptr() as *const [G; OUT_96]) }; __ret }, _ => aiur_fn_96(__args, record, io_buffer, __cu)? } };
     let __v_88: G = __r_arr[0];
     let __v_89: G = __r_arr[1];
-    let __ret: [G; OUT_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_66, __v_77, __v_88, __v_89];
-    record.function_queries[114].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_119] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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_66, __v_77, __v_88, __v_89];
+    record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_115: usize = 1;
-const IN_115: usize = 1;
-const OUT_115: usize = 2;
-fn aiur_fn_115(
-  inp: [G; IN_115],
+const INPUT_SIZE_120: usize = 1;
+const IN_120: usize = 1;
+const OUT_120: usize = 2;
+fn aiur_fn_120(
+  inp: [G; IN_120],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_115], ExecError> {
+) -> Result<[G; OUT_120], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -14626,36 +14814,36 @@ fn aiur_fn_115(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_115] = [__v_5, __v_7];
-        record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_120] = [__v_5, __v_7];
+        record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_115] = [__v_0, __v_7];
-        record.function_queries[115].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_120] = [__v_0, __v_7];
+        record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_116: usize = 1;
-const IN_116: usize = 1;
-const OUT_116: usize = 1;
-fn aiur_fn_116(
-  inp: [G; IN_116],
+const INPUT_SIZE_121: usize = 1;
+const IN_121: usize = 1;
+const OUT_121: usize = 1;
+fn aiur_fn_121(
+  inp: [G; IN_121],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_116], ExecError> {
+) -> Result<[G; OUT_121], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -14684,8 +14872,8 @@ fn aiur_fn_116(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_116] = [__v_23];
-        record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_121] = [__v_23];
+        record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -14711,17 +14899,17 @@ fn aiur_fn_116(
           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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_116] = [__v_29];
-            record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_121] = [__v_29];
+            record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_28: G = G::from_u64(0);
-            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_116] = [__v_30];
-            record.function_queries[116].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_121] = [__v_30];
+            record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -14733,15 +14921,15 @@ fn aiur_fn_116(
   })
 }
 
-const INPUT_SIZE_117: usize = 3;
-const IN_117: usize = 3;
-const OUT_117: usize = 1;
-fn aiur_fn_117(
-  inp: [G; IN_117],
+const INPUT_SIZE_122: usize = 3;
+const IN_122: usize = 3;
+const OUT_122: usize = 1;
+fn aiur_fn_122(
+  inp: [G; IN_122],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_117], ExecError> {
+) -> Result<[G; OUT_122], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14761,15 +14949,15 @@ fn aiur_fn_117(
       1u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_117] = [__v_1];
-            record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_122] = [__v_1];
+            record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __ret: [G; OUT_117] = [__v_13];
-            record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_122] = [__v_13];
+            record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -14790,15 +14978,15 @@ fn aiur_fn_117(
           1u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_117] = [__v_0];
-                record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_122] = [__v_0];
+                record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_117] = [__v_23];
-                record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_122] = [__v_23];
+                record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -14833,11 +15021,11 @@ fn aiur_fn_117(
             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_117] = { let __args: [G; IN_117] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_117] = [__v_51];
-            record.function_queries[117].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_122] = [__v_51];
+            record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -14852,36 +15040,36 @@ fn aiur_fn_117(
   })
 }
 
-const INPUT_SIZE_118: usize = 2;
-const IN_118: usize = 2;
-const OUT_118: usize = 1;
-fn aiur_fn_118(
-  inp: [G; IN_118],
+const INPUT_SIZE_123: usize = 2;
+const IN_123: usize = 2;
+const OUT_123: usize = 1;
+fn aiur_fn_123(
+  inp: [G; IN_123],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_118], ExecError> {
+) -> Result<[G; OUT_123], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[117].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[117].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[117].bump_multiplicity(__i); } let __ret: [G; OUT_117] = unsafe { *(record.function_queries[117].output_at(__i).as_ptr() as *const [G; OUT_117]) }; __ret }, _ => aiur_fn_117(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_118] = [__v_3];
-    record.function_queries[118].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_123] = [__v_3];
+    record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_119: usize = 16;
-const IN_119: usize = 16;
-const OUT_119: usize = 9;
-fn aiur_fn_119(
-  inp: [G; IN_119],
+const INPUT_SIZE_124: usize = 16;
+const IN_124: usize = 16;
+const OUT_124: usize = 9;
+fn aiur_fn_124(
+  inp: [G; IN_124],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_119], ExecError> {
+) -> Result<[G; OUT_124], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14951,21 +15139,21 @@ fn aiur_fn_119(
     let __v_50: G = __b2_sub.0;
     let __v_51: G = __b2_sub.1;
     let __v_52: G = (__v_49 + __v_51);
-    let __ret: [G; OUT_119] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
-    record.function_queries[119].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_124] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52];
+    record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_120: usize = 3;
-const IN_120: usize = 3;
-const OUT_120: usize = 2;
-fn aiur_fn_120(
-  inp: [G; IN_120],
+const INPUT_SIZE_125: usize = 3;
+const IN_125: usize = 3;
+const OUT_125: usize = 2;
+fn aiur_fn_125(
+  inp: [G; IN_125],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_120], ExecError> {
+) -> Result<[G; OUT_125], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -14999,20 +15187,20 @@ fn aiur_fn_120(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_120] = [__v_25, __v_2];
-            record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_125] = [__v_25, __v_2];
+            record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
             match __v_23.as_canonical_u64() {
               1u64 => {
                 let __v_24: G = G::from_u64(1);
                 let __v_25: G = G::from_u64(1);
                 let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_120] = [__v_26, __v_2];
-                record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_125] = [__v_26, __v_2];
+                record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -15020,8 +15208,8 @@ fn aiur_fn_120(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_120] = [__v_26, __v_27];
-                record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_125] = [__v_26, __v_27];
+                record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -15048,8 +15236,8 @@ fn aiur_fn_120(
             match __v_2.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_120] = [__v_0, __v_23];
-                record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_125] = [__v_0, __v_23];
+                record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -15061,7 +15249,7 @@ fn aiur_fn_120(
                 let __v_28: G = G::from_u64(0);
                 let __v_29: G = G::from_u64(0);
                 let __v_30: G = G::from_u64(0);
-                let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__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];
@@ -15074,19 +15262,19 @@ fn aiur_fn_120(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_120] = [__v_46, __v_44];
-                record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_125] = [__v_46, __v_44];
+                record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           0u64 => {
-            let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__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; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__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];
@@ -15103,7 +15291,7 @@ fn aiur_fn_120(
             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_119] = { let __args: [G; IN_119] = [__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; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__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; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__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];
@@ -15114,13 +15302,13 @@ fn aiur_fn_120(
             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_120] = { let __args: [G; IN_120] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_120] = [__v_52, __v_50];
-            record.function_queries[120].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_125] = [__v_52, __v_50];
+            record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -15135,15 +15323,15 @@ fn aiur_fn_120(
   })
 }
 
-const INPUT_SIZE_121: usize = 1;
-const IN_121: usize = 1;
-const OUT_121: usize = 1;
-fn aiur_fn_121(
-  inp: [G; IN_121],
+const INPUT_SIZE_126: usize = 1;
+const IN_126: usize = 1;
+const OUT_126: usize = 1;
+fn aiur_fn_126(
+  inp: [G; IN_126],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_121], ExecError> {
+) -> Result<[G; OUT_126], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -15162,8 +15350,8 @@ fn aiur_fn_121(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_121] = [__v_13];
-        record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_126] = [__v_13];
+        record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -15172,11 +15360,11 @@ fn aiur_fn_121(
         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_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_121] = [__v_13];
-        record.function_queries[121].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_126] = [__v_13];
+        record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -15186,15 +15374,15 @@ fn aiur_fn_121(
   })
 }
 
-const INPUT_SIZE_122: usize = 1;
-const IN_122: usize = 1;
-const OUT_122: usize = 1;
-fn aiur_fn_122(
-  inp: [G; IN_122],
+const INPUT_SIZE_127: usize = 1;
+const IN_127: usize = 1;
+const OUT_127: usize = 1;
+fn aiur_fn_127(
+  inp: [G; IN_127],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_122], ExecError> {
+) -> Result<[G; OUT_127], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -15213,12 +15401,12 @@ fn aiur_fn_122(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_122] = [__v_13];
-        record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_127] = [__v_13];
+        record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
         let __v_12: G = __loaded[0];
@@ -15240,8 +15428,8 @@ fn aiur_fn_122(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_122] = [__v_25];
-                record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_127] = [__v_25];
+                record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
@@ -15250,8 +15438,8 @@ fn aiur_fn_122(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_122] = [__v_27];
-                record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_127] = [__v_27];
+                record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -15262,8 +15450,8 @@ fn aiur_fn_122(
           _ => {
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_122] = [__v_23];
-            record.function_queries[122].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_127] = [__v_23];
+            record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -15275,20 +15463,20 @@ fn aiur_fn_122(
   })
 }
 
-const INPUT_SIZE_123: usize = 2;
-const IN_123: usize = 2;
-const OUT_123: usize = 1;
-fn aiur_fn_123(
-  inp: [G; IN_123],
+const INPUT_SIZE_128: usize = 2;
+const IN_128: usize = 2;
+const OUT_128: usize = 1;
+fn aiur_fn_128(
+  inp: [G; IN_128],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_123], ExecError> {
+) -> Result<[G; OUT_128], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -15296,15 +15484,15 @@ fn aiur_fn_123(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_123] = [__v_7];
-        record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_128] = [__v_7];
+        record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_123] = [__v_5];
-        record.function_queries[123].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_128] = [__v_5];
+        record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -15314,19 +15502,19 @@ fn aiur_fn_123(
   })
 }
 
-const INPUT_SIZE_124: usize = 2;
-const IN_124: usize = 2;
-const OUT_124: usize = 1;
-fn aiur_fn_124(
-  inp: [G; IN_124],
+const INPUT_SIZE_129: usize = 2;
+const IN_129: usize = 2;
+const OUT_129: usize = 1;
+fn aiur_fn_129(
+  inp: [G; IN_129],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_124], ExecError> {
+) -> Result<[G; OUT_129], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -15342,29 +15530,29 @@ fn aiur_fn_124(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_13: G = G::from_u64(1);
-        let __ret: [G; OUT_124] = [__v_13];
-        record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_129] = [__v_13];
+        record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_124] = [__v_13];
-        record.function_queries[124].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_129] = [__v_13];
+        record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_125: usize = 1;
-const IN_125: usize = 1;
-const OUT_125: usize = 1;
-fn aiur_fn_125(
-  inp: [G; IN_125],
+const INPUT_SIZE_130: usize = 1;
+const IN_130: usize = 1;
+const OUT_130: usize = 1;
+fn aiur_fn_130(
+  inp: [G; IN_130],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_125], ExecError> {
+) -> Result<[G; OUT_130], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -15380,23 +15568,23 @@ fn aiur_fn_125(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __ret: [G; OUT_125] = [__v_14];
-    record.function_queries[125].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_130] = [__v_14];
+    record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_126: usize = 2;
-const IN_126: usize = 2;
-const OUT_126: usize = 2;
-fn aiur_fn_126(
-  inp: [G; IN_126],
+const INPUT_SIZE_131: usize = 2;
+const IN_131: usize = 2;
+const OUT_131: usize = 2;
+fn aiur_fn_131(
+  inp: [G; IN_131],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_126], ExecError> {
+) -> Result<[G; OUT_131], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15404,8 +15592,8 @@ fn aiur_fn_126(
     let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_126] = [__v_0, __v_1];
-        record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_131] = [__v_0, __v_1];
+        record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -15413,11 +15601,11 @@ fn aiur_fn_126(
         let __v_5: G = (__v_0 - __v_4);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_126] = [__v_8, __v_9];
-        record.function_queries[126].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_131] = [__v_8, __v_9];
+        record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -15427,15 +15615,15 @@ fn aiur_fn_126(
   })
 }
 
-const INPUT_SIZE_127: usize = 16;
-const IN_127: usize = 16;
-const OUT_127: usize = 16;
-fn aiur_fn_127(
-  inp: [G; IN_127],
+const INPUT_SIZE_132: usize = 16;
+const IN_132: usize = 16;
+const OUT_132: usize = 16;
+fn aiur_fn_132(
+  inp: [G; IN_132],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_127], ExecError> {
+) -> Result<[G; OUT_132], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15744,21 +15932,21 @@ fn aiur_fn_127(
     if (__v_237 != __v_254) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_237.as_canonical_u64(), rhs: __v_254.as_canonical_u64(), msg: Some("u64_mul: final carry exceeds one radix digit".to_string()) });
     }
-    let __ret: [G; OUT_127] = [__v_41, __v_42, __v_72, __v_73, __v_105, __v_106, __v_140, __v_141, __v_173, __v_174, __v_204, __v_205, __v_233, __v_234, __v_235, __v_236];
-    record.function_queries[127].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_132] = [__v_41, __v_42, __v_72, __v_73, __v_105, __v_106, __v_140, __v_141, __v_173, __v_174, __v_204, __v_205, __v_233, __v_234, __v_235, __v_236];
+    record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_128: usize = 1;
-const IN_128: usize = 1;
-const OUT_128: usize = 5;
-fn aiur_fn_128(
-  inp: [G; IN_128],
+const INPUT_SIZE_133: usize = 1;
+const IN_133: usize = 1;
+const OUT_133: usize = 5;
+fn aiur_fn_133(
+  inp: [G; IN_133],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_128], ExecError> {
+) -> Result<[G; OUT_133], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
@@ -15789,21 +15977,21 @@ fn aiur_fn_128(
     if (__v_0 != __v_21) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("u64_mul: column hint does not recompose".to_string()) });
     }
-    let __ret: [G; OUT_128] = [__v_1, __v_2, __v_3, __v_4, __v_5];
-    record.function_queries[128].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_133] = [__v_1, __v_2, __v_3, __v_4, __v_5];
+    record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_129: usize = 2;
-const IN_129: usize = 2;
-const OUT_129: usize = 1;
-fn aiur_fn_129(
-  inp: [G; IN_129],
+const INPUT_SIZE_134: usize = 2;
+const IN_134: usize = 2;
+const OUT_134: usize = 1;
+fn aiur_fn_134(
+  inp: [G; IN_134],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_129], ExecError> {
+) -> Result<[G; OUT_134], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15811,23 +15999,23 @@ fn aiur_fn_129(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_130] = { let __args: [G; IN_130] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_129] = [__v_6];
-    record.function_queries[129].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_134] = [__v_6];
+    record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_130: usize = 4;
-const IN_130: usize = 4;
-const OUT_130: usize = 1;
-fn aiur_fn_130(
-  inp: [G; IN_130],
+const INPUT_SIZE_135: usize = 4;
+const IN_135: usize = 4;
+const OUT_135: usize = 1;
+fn aiur_fn_135(
+  inp: [G; IN_135],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_130], ExecError> {
+) -> Result<[G; OUT_135], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15846,8 +16034,8 @@ fn aiur_fn_130(
     let __v_13: G = __loaded[9];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_130] = [__v_2];
-        record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_135] = [__v_2];
+        record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -15859,18 +16047,18 @@ fn aiur_fn_130(
         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 __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__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]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__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]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__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_130] = { let __args: [G; IN_130] = [__v_13, __v_1, __v_24, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_13, __v_1, __v_24, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __ret: [G; OUT_130] = [__v_27];
-        record.function_queries[130].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_135] = [__v_27];
+        record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -15880,15 +16068,15 @@ fn aiur_fn_130(
   })
 }
 
-const INPUT_SIZE_131: usize = 17;
-const IN_131: usize = 17;
-const OUT_131: usize = 1;
-fn aiur_fn_131(
-  inp: [G; IN_131],
+const INPUT_SIZE_136: usize = 17;
+const IN_136: usize = 17;
+const OUT_136: usize = 1;
+fn aiur_fn_136(
+  inp: [G; IN_136],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_131], ExecError> {
+) -> Result<[G; OUT_136], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -15927,8 +16115,8 @@ fn aiur_fn_131(
             let __v_28: G = G::from_u64(1);
             let __v_29: G = G::from_u64(1);
             let __v_30: G = { let __values: [G; 10] = [__v_28, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_131] = [__v_30];
-            record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_136] = [__v_30];
+            record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -15937,8 +16125,8 @@ fn aiur_fn_131(
             let __v_30: G = G::from_u64(1);
             let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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; 10] = [__v_28, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_131] = [__v_32];
-            record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_136] = [__v_32];
+            record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -15947,7 +16135,7 @@ fn aiur_fn_131(
         }
       },
       0u64 => {
-        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__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; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__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; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__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];
@@ -15977,11 +16165,11 @@ fn aiur_fn_131(
         match __v_51.as_canonical_u64() {
           0u64 => {
             let __v_52: G = G::from_u64(0);
-            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = { let __values: [G; 10] = [__v_52, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_53]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_131] = [__v_54];
-            record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_136] = [__v_54];
+            record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -15995,11 +16183,11 @@ fn aiur_fn_131(
             let __v_58: G = __r_arr[5];
             let __v_59: G = __r_arr[6];
             let __v_60: G = __r_arr[7];
-            let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_26, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
             let __v_61: G = __r_arr[0];
             let __v_62: G = { let __values: [G; 10] = [__v_52, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_61]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_131] = [__v_62];
-            record.function_queries[131].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_136] = [__v_62];
+            record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -16011,22 +16199,22 @@ fn aiur_fn_131(
   })
 }
 
-const INPUT_SIZE_132: usize = 2;
-const IN_132: usize = 2;
-const OUT_132: usize = 1;
-fn aiur_fn_132(
-  inp: [G; IN_132],
+const INPUT_SIZE_137: usize = 2;
+const IN_137: usize = 2;
+const OUT_137: usize = 1;
+fn aiur_fn_137(
+  inp: [G; IN_137],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_132], ExecError> {
+) -> Result<[G; OUT_137], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_132] = [__v_0];
-        record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_137] = [__v_0];
+        record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -16042,28 +16230,28 @@ fn aiur_fn_132(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_132] = { let __args: [G; IN_132] = [__v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[132].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[132].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[132].bump_multiplicity(__i); } let __ret: [G; OUT_132] = unsafe { *(record.function_queries[132].output_at(__i).as_ptr() as *const [G; OUT_132]) }; __ret }, _ => aiur_fn_132(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_132] = [__v_14];
-        record.function_queries[132].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_137] = [__v_14];
+        record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_133: usize = 1;
-const IN_133: usize = 1;
-const OUT_133: usize = 1;
-fn aiur_fn_133(
-  inp: [G; IN_133],
+const INPUT_SIZE_138: usize = 1;
+const IN_138: usize = 1;
+const OUT_138: usize = 1;
+fn aiur_fn_138(
+  inp: [G; IN_138],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_133], ExecError> {
+) -> Result<[G; OUT_138], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -16079,79 +16267,79 @@ fn aiur_fn_133(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_133] = [__v_12];
-        record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_138] = [__v_12];
+        record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_133] = [__v_12];
-        record.function_queries[133].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_138] = [__v_12];
+        record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_134: usize = 2;
-const IN_134: usize = 2;
-const OUT_134: usize = 2;
-fn aiur_fn_134(
-  inp: [G; IN_134],
+const INPUT_SIZE_139: usize = 2;
+const IN_139: usize = 2;
+const OUT_139: usize = 2;
+fn aiur_fn_139(
+  inp: [G; IN_139],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_134], ExecError> {
+) -> Result<[G; OUT_139], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __bu_qr: (G, G) = unconstrained_big_uint_div_mod_helper(__v_0, __v_1, record)?;
     let __v_2: G = __bu_qr.0;
     let __v_3: G = __bu_qr.1;
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_8, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     if (__v_10 != __v_11) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64(), msg: Some("div/mod hint: q*b + r != a".to_string()) });
     }
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     match __v_12.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__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("div/mod hint: division by zero must yield a zero quotient".to_string()) });
         }
-        let __ret: [G; OUT_134] = [__v_5, __v_7];
-        record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_139] = [__v_5, __v_7];
+        record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(1);
         if (__v_14 != __v_15) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("div/mod hint: remainder is not less than the divisor".to_string()) });
         }
-        let __ret: [G; OUT_134] = [__v_5, __v_7];
-        record.function_queries[134].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_139] = [__v_5, __v_7];
+        record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -16161,75 +16349,75 @@ fn aiur_fn_134(
   })
 }
 
-const INPUT_SIZE_135: usize = 2;
-const IN_135: usize = 2;
-const OUT_135: usize = 1;
-fn aiur_fn_135(
-  inp: [G; IN_135],
+const INPUT_SIZE_140: usize = 2;
+const IN_140: usize = 2;
+const OUT_140: usize = 1;
+fn aiur_fn_140(
+  inp: [G; IN_140],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_135], ExecError> {
+) -> Result<[G; OUT_140], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_135] = [__v_2];
-    record.function_queries[135].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_140] = [__v_2];
+    record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_136: usize = 2;
-const IN_136: usize = 2;
-const OUT_136: usize = 1;
-fn aiur_fn_136(
-  inp: [G; IN_136],
+const INPUT_SIZE_141: usize = 2;
+const IN_141: usize = 2;
+const OUT_141: usize = 1;
+fn aiur_fn_141(
+  inp: [G; IN_141],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_136], ExecError> {
+) -> Result<[G; OUT_141], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __ret: [G; OUT_136] = [__v_3];
-    record.function_queries[136].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_141] = [__v_3];
+    record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_137: usize = 2;
-const IN_137: usize = 2;
-const OUT_137: usize = 1;
-fn aiur_fn_137(
-  inp: [G; IN_137],
+const INPUT_SIZE_142: usize = 2;
+const IN_142: usize = 2;
+const OUT_142: usize = 1;
+fn aiur_fn_142(
+  inp: [G; IN_142],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_137], ExecError> {
+) -> Result<[G; OUT_142], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_137] = [__v_0];
-        record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_142] = [__v_0];
+        record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_137] = [__v_4];
-        record.function_queries[137].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_142] = [__v_4];
+        record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -16239,19 +16427,19 @@ fn aiur_fn_137(
   })
 }
 
-const INPUT_SIZE_138: usize = 2;
-const IN_138: usize = 2;
-const OUT_138: usize = 1;
-fn aiur_fn_138(
-  inp: [G; IN_138],
+const INPUT_SIZE_143: usize = 2;
+const IN_143: usize = 2;
+const OUT_143: usize = 1;
+fn aiur_fn_143(
+  inp: [G; IN_143],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_138], ExecError> {
+) -> Result<[G; OUT_143], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
@@ -16268,8 +16456,8 @@ fn aiur_fn_138(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_138] = [__v_15];
-        record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_143] = [__v_15];
+        record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -16286,30 +16474,30 @@ fn aiur_fn_138(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = __r_arr[1];
-        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         match __v_22.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_138] = [__v_21];
-            record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_143] = [__v_21];
+            record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_138] = [__v_23];
-            record.function_queries[138].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_143] = [__v_23];
+            record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -16324,15 +16512,15 @@ fn aiur_fn_138(
   })
 }
 
-const INPUT_SIZE_139: usize = 16;
-const IN_139: usize = 16;
-const OUT_139: usize = 8;
-fn aiur_fn_139(
-  inp: [G; IN_139],
+const INPUT_SIZE_144: usize = 16;
+const IN_144: usize = 16;
+const OUT_144: usize = 8;
+fn aiur_fn_144(
+  inp: [G; IN_144],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_139], ExecError> {
+) -> Result<[G; OUT_144], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16358,21 +16546,21 @@ fn aiur_fn_139(
     let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) };
     let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) };
     let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) };
-    let __ret: [G; OUT_139] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[139].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_144] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_140: usize = 16;
-const IN_140: usize = 16;
-const OUT_140: usize = 8;
-fn aiur_fn_140(
-  inp: [G; IN_140],
+const INPUT_SIZE_145: usize = 16;
+const IN_145: usize = 16;
+const OUT_145: usize = 8;
+fn aiur_fn_145(
+  inp: [G; IN_145],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_140], ExecError> {
+) -> Result<[G; OUT_145], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16398,21 +16586,21 @@ fn aiur_fn_140(
     let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) };
     let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) };
     let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) };
-    let __ret: [G; OUT_140] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[140].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_145] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_141: usize = 16;
-const IN_141: usize = 16;
-const OUT_141: usize = 8;
-fn aiur_fn_141(
-  inp: [G; IN_141],
+const INPUT_SIZE_146: usize = 16;
+const IN_146: usize = 16;
+const OUT_146: usize = 8;
+fn aiur_fn_146(
+  inp: [G; IN_146],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_141], ExecError> {
+) -> Result<[G; OUT_146], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16438,21 +16626,21 @@ fn aiur_fn_141(
     let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) };
     let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) };
     let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) };
-    let __ret: [G; OUT_141] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
-    record.function_queries[141].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_146] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23];
+    record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_142: usize = 2;
-const IN_142: usize = 2;
-const OUT_142: usize = 1;
-fn aiur_fn_142(
-  inp: [G; IN_142],
+const INPUT_SIZE_147: usize = 2;
+const IN_147: usize = 2;
+const OUT_147: usize = 1;
+fn aiur_fn_147(
+  inp: [G; IN_147],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_142], ExecError> {
+) -> Result<[G; OUT_147], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16472,8 +16660,8 @@ fn aiur_fn_142(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_142] = [__v_14];
-        record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_147] = [__v_14];
+        record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -16493,13 +16681,13 @@ fn aiur_fn_142(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_142] = [__v_24];
-            record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_147] = [__v_24];
+            record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__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; let __hit = record.function_queries[139].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[139].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[139].bump_multiplicity(__i); } let __ret: [G; OUT_139] = unsafe { *(record.function_queries[139].output_at(__i).as_ptr() as *const [G; OUT_139]) }; __ret }, _ => aiur_fn_139(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__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; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__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];
@@ -16508,11 +16696,11 @@ fn aiur_fn_142(
             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_142] = { let __args: [G; IN_142] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_142] = [__v_32];
-            record.function_queries[142].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_147] = [__v_32];
+            record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -16527,15 +16715,15 @@ fn aiur_fn_142(
   })
 }
 
-const INPUT_SIZE_143: usize = 2;
-const IN_143: usize = 2;
-const OUT_143: usize = 1;
-fn aiur_fn_143(
-  inp: [G; IN_143],
+const INPUT_SIZE_148: usize = 2;
+const IN_148: usize = 2;
+const OUT_148: usize = 1;
+fn aiur_fn_148(
+  inp: [G; IN_148],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_143], ExecError> {
+) -> Result<[G; OUT_148], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16552,8 +16740,8 @@ fn aiur_fn_143(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_143] = [__v_1];
-        record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_148] = [__v_1];
+        record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -16570,13 +16758,13 @@ fn aiur_fn_143(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_143] = [__v_0];
-            record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_148] = [__v_0];
+            record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__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; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } };
+            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_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__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];
@@ -16585,11 +16773,11 @@ fn aiur_fn_143(
             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_143] = { let __args: [G; IN_143] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_143] = [__v_32];
-            record.function_queries[143].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_148] = [__v_32];
+            record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -16604,15 +16792,15 @@ fn aiur_fn_143(
   })
 }
 
-const INPUT_SIZE_144: usize = 2;
-const IN_144: usize = 2;
-const OUT_144: usize = 1;
-fn aiur_fn_144(
-  inp: [G; IN_144],
+const INPUT_SIZE_149: usize = 2;
+const IN_149: usize = 2;
+const OUT_149: usize = 1;
+fn aiur_fn_149(
+  inp: [G; IN_149],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_144], ExecError> {
+) -> Result<[G; OUT_149], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16629,8 +16817,8 @@ fn aiur_fn_144(
     let __v_11: G = __loaded[9];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_144] = [__v_1];
-        record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_149] = [__v_1];
+        record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -16647,13 +16835,13 @@ fn aiur_fn_144(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_144] = [__v_0];
-            record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_149] = [__v_0];
+            record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_22: G = G::from_u64(0);
-            let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__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; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } };
+            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_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__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];
@@ -16662,11 +16850,11 @@ fn aiur_fn_144(
             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_144] = { let __args: [G; IN_144] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_144] = [__v_32];
-            record.function_queries[144].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_149] = [__v_32];
+            record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -16681,15 +16869,15 @@ fn aiur_fn_144(
   })
 }
 
-const INPUT_SIZE_145: usize = 2;
-const IN_145: usize = 2;
-const OUT_145: usize = 1;
-fn aiur_fn_145(
-  inp: [G; IN_145],
+const INPUT_SIZE_150: usize = 2;
+const IN_150: usize = 2;
+const OUT_150: usize = 1;
+fn aiur_fn_150(
+  inp: [G; IN_150],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_145], ExecError> {
+) -> Result<[G; OUT_150], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16706,25 +16894,25 @@ fn aiur_fn_145(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_145] = [__v_16];
-    record.function_queries[145].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_150] = [__v_16];
+    record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_146: usize = 2;
-const IN_146: usize = 2;
-const OUT_146: usize = 1;
-fn aiur_fn_146(
-  inp: [G; IN_146],
+const INPUT_SIZE_151: usize = 2;
+const IN_151: usize = 2;
+const OUT_151: usize = 1;
+fn aiur_fn_151(
+  inp: [G; IN_151],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_146], ExecError> {
+) -> Result<[G; OUT_151], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -16741,256 +16929,11 @@ fn aiur_fn_146(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __ret: [G; OUT_146] = [__v_16];
-    record.function_queries[146].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_147: usize = 0;
-const IN_147: usize = 0;
-const OUT_147: usize = 1;
-fn aiur_fn_147(
-  inp: [G; IN_147],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_147], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(80);
-    let __v_1: G = G::from_u64(229);
-    let __v_2: G = G::from_u64(214);
-    let __v_3: G = G::from_u64(157);
-    let __v_4: G = G::from_u64(128);
-    let __v_5: G = G::from_u64(107);
-    let __v_6: G = G::from_u64(193);
-    let __v_7: G = G::from_u64(198);
-    let __v_8: G = G::from_u64(22);
-    let __v_9: G = G::from_u64(202);
-    let __v_10: G = G::from_u64(206);
-    let __v_11: G = G::from_u64(66);
-    let __v_12: G = G::from_u64(48);
-    let __v_13: G = G::from_u64(201);
-    let __v_14: G = G::from_u64(130);
-    let __v_15: G = G::from_u64(160);
-    let __v_16: G = G::from_u64(238);
-    let __v_17: G = G::from_u64(91);
-    let __v_18: G = G::from_u64(53);
-    let __v_19: G = G::from_u64(11);
-    let __v_20: G = G::from_u64(62);
-    let __v_21: G = G::from_u64(254);
-    let __v_22: G = G::from_u64(59);
-    let __v_23: G = G::from_u64(26);
-    let __v_24: G = G::from_u64(21);
-    let __v_25: G = G::from_u64(128);
-    let __v_26: G = G::from_u64(29);
-    let __v_27: G = G::from_u64(247);
-    let __v_28: G = G::from_u64(127);
-    let __v_29: G = G::from_u64(192);
-    let __v_30: G = G::from_u64(12);
-    let __v_31: G = G::from_u64(140);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_147] = [__v_32];
-    record.function_queries[147].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_148: usize = 0;
-const IN_148: usize = 0;
-const OUT_148: usize = 1;
-fn aiur_fn_148(
-  inp: [G; IN_148],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_148], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(140);
-    let __v_1: G = G::from_u64(9);
-    let __v_2: G = G::from_u64(202);
-    let __v_3: G = G::from_u64(100);
-    let __v_4: G = G::from_u64(75);
-    let __v_5: G = G::from_u64(16);
-    let __v_6: G = G::from_u64(222);
-    let __v_7: G = G::from_u64(202);
-    let __v_8: G = G::from_u64(209);
-    let __v_9: G = G::from_u64(88);
-    let __v_10: G = G::from_u64(211);
-    let __v_11: G = G::from_u64(112);
-    let __v_12: G = G::from_u64(6);
-    let __v_13: G = G::from_u64(232);
-    let __v_14: G = G::from_u64(28);
-    let __v_15: G = G::from_u64(220);
-    let __v_16: G = G::from_u64(27);
-    let __v_17: G = G::from_u64(132);
-    let __v_18: G = G::from_u64(118);
-    let __v_19: G = G::from_u64(19);
-    let __v_20: G = G::from_u64(18);
-    let __v_21: G = G::from_u64(38);
-    let __v_22: G = G::from_u64(5);
-    let __v_23: G = G::from_u64(70);
-    let __v_24: G = G::from_u64(68);
-    let __v_25: G = G::from_u64(154);
-    let __v_26: G = G::from_u64(160);
-    let __v_27: G = G::from_u64(46);
-    let __v_28: G = G::from_u64(52);
-    let __v_29: G = G::from_u64(59);
-    let __v_30: G = G::from_u64(43);
-    let __v_31: G = G::from_u64(12);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_148] = [__v_32];
-    record.function_queries[148].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_149: usize = 0;
-const IN_149: usize = 0;
-const OUT_149: usize = 1;
-fn aiur_fn_149(
-  inp: [G; IN_149],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_149], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(252);
-    let __v_1: G = G::from_u64(233);
-    let __v_2: G = G::from_u64(22);
-    let __v_3: G = G::from_u64(207);
-    let __v_4: G = G::from_u64(60);
-    let __v_5: G = G::from_u64(109);
-    let __v_6: G = G::from_u64(208);
-    let __v_7: G = G::from_u64(26);
-    let __v_8: G = G::from_u64(216);
-    let __v_9: G = G::from_u64(198);
-    let __v_10: G = G::from_u64(211);
-    let __v_11: G = G::from_u64(134);
-    let __v_12: G = G::from_u64(65);
-    let __v_13: G = G::from_u64(188);
-    let __v_14: G = G::from_u64(167);
-    let __v_15: G = G::from_u64(179);
-    let __v_16: G = G::from_u64(238);
-    let __v_17: G = G::from_u64(172);
-    let __v_18: G = G::from_u64(91);
-    let __v_19: G = G::from_u64(201);
-    let __v_20: G = G::from_u64(59);
-    let __v_21: G = G::from_u64(53);
-    let __v_22: G = G::from_u64(41);
-    let __v_23: G = G::from_u64(173);
-    let __v_24: G = G::from_u64(120);
-    let __v_25: G = G::from_u64(18);
-    let __v_26: G = G::from_u64(118);
-    let __v_27: G = G::from_u64(139);
-    let __v_28: G = G::from_u64(52);
-    let __v_29: G = G::from_u64(7);
-    let __v_30: G = G::from_u64(214);
-    let __v_31: G = G::from_u64(78);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_149] = [__v_32];
-    record.function_queries[149].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_150: usize = 0;
-const IN_150: usize = 0;
-const OUT_150: usize = 1;
-fn aiur_fn_150(
-  inp: [G; IN_150],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_150], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(72);
-    let __v_1: G = G::from_u64(120);
-    let __v_2: G = G::from_u64(107);
-    let __v_3: G = G::from_u64(127);
-    let __v_4: G = G::from_u64(122);
-    let __v_5: G = G::from_u64(220);
-    let __v_6: G = G::from_u64(99);
-    let __v_7: G = G::from_u64(42);
-    let __v_8: G = G::from_u64(227);
-    let __v_9: G = G::from_u64(80);
-    let __v_10: G = G::from_u64(89);
-    let __v_11: G = G::from_u64(243);
-    let __v_12: G = G::from_u64(253);
-    let __v_13: G = G::from_u64(24);
-    let __v_14: G = G::from_u64(29);
-    let __v_15: G = G::from_u64(243);
-    let __v_16: G = G::from_u64(45);
-    let __v_17: G = G::from_u64(158);
-    let __v_18: G = G::from_u64(92);
-    let __v_19: G = G::from_u64(199);
-    let __v_20: G = G::from_u64(54);
-    let __v_21: G = G::from_u64(12);
-    let __v_22: G = G::from_u64(79);
-    let __v_23: G = G::from_u64(208);
-    let __v_24: G = G::from_u64(44);
-    let __v_25: G = G::from_u64(62);
-    let __v_26: G = G::from_u64(139);
-    let __v_27: G = G::from_u64(17);
-    let __v_28: G = G::from_u64(129);
-    let __v_29: G = G::from_u64(161);
-    let __v_30: G = G::from_u64(83);
-    let __v_31: G = G::from_u64(155);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_150] = [__v_32];
-    record.function_queries[150].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_151: usize = 0;
-const IN_151: usize = 0;
-const OUT_151: usize = 1;
-fn aiur_fn_151(
-  inp: [G; IN_151],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_151], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(207);
-    let __v_1: G = G::from_u64(201);
-    let __v_2: G = G::from_u64(52);
-    let __v_3: G = G::from_u64(253);
-    let __v_4: G = G::from_u64(109);
-    let __v_5: G = G::from_u64(83);
-    let __v_6: G = G::from_u64(165);
-    let __v_7: G = G::from_u64(178);
-    let __v_8: G = G::from_u64(59);
-    let __v_9: G = G::from_u64(106);
-    let __v_10: G = G::from_u64(59);
-    let __v_11: G = G::from_u64(48);
-    let __v_12: G = G::from_u64(208);
-    let __v_13: G = G::from_u64(33);
-    let __v_14: G = G::from_u64(101);
-    let __v_15: G = G::from_u64(253);
-    let __v_16: G = G::from_u64(170);
-    let __v_17: G = G::from_u64(87);
-    let __v_18: G = G::from_u64(78);
-    let __v_19: G = G::from_u64(59);
-    let __v_20: G = G::from_u64(94);
-    let __v_21: G = G::from_u64(177);
-    let __v_22: G = G::from_u64(57);
-    let __v_23: G = G::from_u64(38);
-    let __v_24: G = G::from_u64(187);
-    let __v_25: G = G::from_u64(22);
-    let __v_26: G = G::from_u64(110);
-    let __v_27: G = G::from_u64(100);
-    let __v_28: G = G::from_u64(134);
-    let __v_29: G = G::from_u64(252);
-    let __v_30: G = G::from_u64(14);
-    let __v_31: G = G::from_u64(80);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_151] = [__v_32];
+    let __ret: [G; OUT_151] = [__v_16];
     record.function_queries[151].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
@@ -17006,38 +16949,38 @@ fn aiur_fn_152(
   unconstrained: bool,
 ) -> Result<[G; OUT_152], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(30);
-    let __v_1: G = G::from_u64(96);
-    let __v_2: G = G::from_u64(189);
-    let __v_3: G = G::from_u64(55);
-    let __v_4: G = G::from_u64(122);
-    let __v_5: G = G::from_u64(116);
-    let __v_6: G = G::from_u64(108);
-    let __v_7: G = G::from_u64(183);
-    let __v_8: G = G::from_u64(189);
-    let __v_9: G = G::from_u64(122);
-    let __v_10: G = G::from_u64(229);
-    let __v_11: G = G::from_u64(65);
-    let __v_12: G = G::from_u64(215);
-    let __v_13: G = G::from_u64(223);
-    let __v_14: G = G::from_u64(178);
-    let __v_15: G = G::from_u64(55);
-    let __v_16: G = G::from_u64(9);
-    let __v_17: G = G::from_u64(125);
-    let __v_18: G = G::from_u64(136);
-    let __v_19: G = G::from_u64(61);
-    let __v_20: G = G::from_u64(40);
-    let __v_21: G = G::from_u64(236);
-    let __v_22: G = G::from_u64(122);
-    let __v_23: G = G::from_u64(173);
-    let __v_24: G = G::from_u64(215);
-    let __v_25: G = G::from_u64(50);
-    let __v_26: G = G::from_u64(192);
-    let __v_27: G = G::from_u64(103);
-    let __v_28: G = G::from_u64(78);
-    let __v_29: G = G::from_u64(13);
-    let __v_30: G = G::from_u64(185);
-    let __v_31: G = G::from_u64(100);
+    let __v_0: G = G::from_u64(238);
+    let __v_1: G = G::from_u64(178);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(38);
+    let __v_4: G = G::from_u64(143);
+    let __v_5: G = G::from_u64(246);
+    let __v_6: G = G::from_u64(208);
+    let __v_7: G = G::from_u64(230);
+    let __v_8: G = G::from_u64(178);
+    let __v_9: G = G::from_u64(233);
+    let __v_10: G = G::from_u64(118);
+    let __v_11: G = G::from_u64(77);
+    let __v_12: G = G::from_u64(153);
+    let __v_13: G = G::from_u64(64);
+    let __v_14: G = G::from_u64(184);
+    let __v_15: G = G::from_u64(27);
+    let __v_16: G = G::from_u64(182);
+    let __v_17: G = G::from_u64(75);
+    let __v_18: G = G::from_u64(159);
+    let __v_19: G = G::from_u64(143);
+    let __v_20: G = G::from_u64(75);
+    let __v_21: G = G::from_u64(19);
+    let __v_22: G = G::from_u64(88);
+    let __v_23: G = G::from_u64(210);
+    let __v_24: G = G::from_u64(148);
+    let __v_25: G = G::from_u64(255);
+    let __v_26: G = G::from_u64(152);
+    let __v_27: G = G::from_u64(23);
+    let __v_28: G = G::from_u64(230);
+    let __v_29: G = G::from_u64(148);
+    let __v_30: G = G::from_u64(26);
+    let __v_31: G = G::from_u64(70);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_152] = [__v_32];
     record.function_queries[152].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17055,38 +16998,38 @@ fn aiur_fn_153(
   unconstrained: bool,
 ) -> Result<[G; OUT_153], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(13);
-    let __v_1: G = G::from_u64(116);
-    let __v_2: G = G::from_u64(186);
-    let __v_3: G = G::from_u64(133);
-    let __v_4: G = G::from_u64(249);
-    let __v_5: G = G::from_u64(116);
-    let __v_6: G = G::from_u64(154);
-    let __v_7: G = G::from_u64(12);
-    let __v_8: G = G::from_u64(37);
-    let __v_9: G = G::from_u64(170);
-    let __v_10: G = G::from_u64(106);
-    let __v_11: G = G::from_u64(43);
-    let __v_12: G = G::from_u64(112);
-    let __v_13: G = G::from_u64(52);
-    let __v_14: G = G::from_u64(142);
-    let __v_15: G = G::from_u64(87);
-    let __v_16: G = G::from_u64(231);
-    let __v_17: G = G::from_u64(9);
+    let __v_0: G = G::from_u64(66);
+    let __v_1: G = G::from_u64(214);
+    let __v_2: G = G::from_u64(237);
+    let __v_3: G = G::from_u64(49);
+    let __v_4: G = G::from_u64(83);
+    let __v_5: G = G::from_u64(111);
+    let __v_6: G = G::from_u64(9);
+    let __v_7: G = G::from_u64(88);
+    let __v_8: G = G::from_u64(23);
+    let __v_9: G = G::from_u64(111);
+    let __v_10: G = G::from_u64(29);
+    let __v_11: G = G::from_u64(201);
+    let __v_12: G = G::from_u64(115);
+    let __v_13: G = G::from_u64(56);
+    let __v_14: G = G::from_u64(56);
+    let __v_15: G = G::from_u64(8);
+    let __v_16: G = G::from_u64(172);
+    let __v_17: G = G::from_u64(133);
     let __v_18: G = G::from_u64(131);
-    let __v_19: G = G::from_u64(31);
-    let __v_20: G = G::from_u64(183);
-    let __v_21: G = G::from_u64(204);
-    let __v_22: G = G::from_u64(5);
-    let __v_23: G = G::from_u64(34);
-    let __v_24: G = G::from_u64(159);
-    let __v_25: G = G::from_u64(236);
-    let __v_26: G = G::from_u64(215);
-    let __v_27: G = G::from_u64(214);
-    let __v_28: G = G::from_u64(106);
-    let __v_29: G = G::from_u64(223);
-    let __v_30: G = G::from_u64(24);
-    let __v_31: G = G::from_u64(77);
+    let __v_19: G = G::from_u64(34);
+    let __v_20: G = G::from_u64(55);
+    let __v_21: G = G::from_u64(70);
+    let __v_22: G = G::from_u64(235);
+    let __v_23: G = G::from_u64(202);
+    let __v_24: G = G::from_u64(120);
+    let __v_25: G = G::from_u64(219);
+    let __v_26: G = G::from_u64(227);
+    let __v_27: G = G::from_u64(137);
+    let __v_28: G = G::from_u64(182);
+    let __v_29: G = G::from_u64(83);
+    let __v_30: G = G::from_u64(33);
+    let __v_31: G = G::from_u64(166);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_153] = [__v_32];
     record.function_queries[153].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17104,38 +17047,38 @@ fn aiur_fn_154(
   unconstrained: bool,
 ) -> Result<[G; OUT_154], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(197);
-    let __v_1: G = G::from_u64(190);
-    let __v_2: G = G::from_u64(246);
-    let __v_3: G = G::from_u64(190);
-    let __v_4: G = G::from_u64(108);
-    let __v_5: G = G::from_u64(63);
-    let __v_6: G = G::from_u64(220);
-    let __v_7: G = G::from_u64(82);
-    let __v_8: G = G::from_u64(4);
-    let __v_9: G = G::from_u64(84);
-    let __v_10: G = G::from_u64(193);
-    let __v_11: G = G::from_u64(30);
-    let __v_12: G = G::from_u64(153);
-    let __v_13: G = G::from_u64(80);
-    let __v_14: G = G::from_u64(235);
-    let __v_15: G = G::from_u64(47);
-    let __v_16: G = G::from_u64(26);
-    let __v_17: G = G::from_u64(108);
-    let __v_18: G = G::from_u64(146);
-    let __v_19: G = G::from_u64(244);
-    let __v_20: G = G::from_u64(26);
-    let __v_21: G = G::from_u64(100);
-    let __v_22: G = G::from_u64(107);
-    let __v_23: G = G::from_u64(92);
-    let __v_24: G = G::from_u64(161);
-    let __v_25: G = G::from_u64(104);
-    let __v_26: G = G::from_u64(255);
-    let __v_27: G = G::from_u64(25);
-    let __v_28: G = G::from_u64(143);
-    let __v_29: G = G::from_u64(19);
-    let __v_30: G = G::from_u64(197);
-    let __v_31: G = G::from_u64(90);
+    let __v_0: G = G::from_u64(118);
+    let __v_1: G = G::from_u64(175);
+    let __v_2: G = G::from_u64(162);
+    let __v_3: G = G::from_u64(84);
+    let __v_4: G = G::from_u64(168);
+    let __v_5: G = G::from_u64(187);
+    let __v_6: G = G::from_u64(242);
+    let __v_7: G = G::from_u64(172);
+    let __v_8: G = G::from_u64(67);
+    let __v_9: G = G::from_u64(39);
+    let __v_10: G = G::from_u64(215);
+    let __v_11: G = G::from_u64(185);
+    let __v_12: G = G::from_u64(75);
+    let __v_13: G = G::from_u64(224);
+    let __v_14: G = G::from_u64(198);
+    let __v_15: G = G::from_u64(59);
+    let __v_16: G = G::from_u64(215);
+    let __v_17: G = G::from_u64(8);
+    let __v_18: G = G::from_u64(131);
+    let __v_19: G = G::from_u64(107);
+    let __v_20: G = G::from_u64(95);
+    let __v_21: G = G::from_u64(115);
+    let __v_22: G = G::from_u64(132);
+    let __v_23: G = G::from_u64(206);
+    let __v_24: G = G::from_u64(153);
+    let __v_25: G = G::from_u64(3);
+    let __v_26: G = G::from_u64(136);
+    let __v_27: G = G::from_u64(173);
+    let __v_28: G = G::from_u64(176);
+    let __v_29: G = G::from_u64(161);
+    let __v_30: G = G::from_u64(211);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_154] = [__v_32];
     record.function_queries[154].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17153,38 +17096,38 @@ fn aiur_fn_155(
   unconstrained: bool,
 ) -> Result<[G; OUT_155], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(188);
-    let __v_1: G = G::from_u64(97);
-    let __v_2: G = G::from_u64(193);
-    let __v_3: G = G::from_u64(15);
-    let __v_4: G = G::from_u64(204);
-    let __v_5: G = G::from_u64(166);
-    let __v_6: G = G::from_u64(65);
-    let __v_7: G = G::from_u64(82);
-    let __v_8: G = G::from_u64(35);
-    let __v_9: G = G::from_u64(237);
-    let __v_10: G = G::from_u64(151);
-    let __v_11: G = G::from_u64(188);
-    let __v_12: G = G::from_u64(174);
-    let __v_13: G = G::from_u64(33);
-    let __v_14: G = G::from_u64(203);
-    let __v_15: G = G::from_u64(153);
-    let __v_16: G = G::from_u64(212);
-    let __v_17: G = G::from_u64(131);
-    let __v_18: G = G::from_u64(109);
-    let __v_19: G = G::from_u64(7);
-    let __v_20: G = G::from_u64(123);
-    let __v_21: G = G::from_u64(7);
-    let __v_22: G = G::from_u64(134);
-    let __v_23: G = G::from_u64(162);
-    let __v_24: G = G::from_u64(252);
-    let __v_25: G = G::from_u64(92);
-    let __v_26: G = G::from_u64(89);
-    let __v_27: G = G::from_u64(5);
-    let __v_28: G = G::from_u64(248);
-    let __v_29: G = G::from_u64(176);
-    let __v_30: G = G::from_u64(75);
-    let __v_31: G = G::from_u64(162);
+    let __v_0: G = G::from_u64(10);
+    let __v_1: G = G::from_u64(153);
+    let __v_2: G = G::from_u64(244);
+    let __v_3: G = G::from_u64(156);
+    let __v_4: G = G::from_u64(199);
+    let __v_5: G = G::from_u64(58);
+    let __v_6: G = G::from_u64(185);
+    let __v_7: G = G::from_u64(244);
+    let __v_8: G = G::from_u64(39);
+    let __v_9: G = G::from_u64(131);
+    let __v_10: G = G::from_u64(9);
+    let __v_11: G = G::from_u64(46);
+    let __v_12: G = G::from_u64(113);
+    let __v_13: G = G::from_u64(32);
+    let __v_14: G = G::from_u64(97);
+    let __v_15: G = G::from_u64(50);
+    let __v_16: G = G::from_u64(37);
+    let __v_17: G = G::from_u64(103);
+    let __v_18: G = G::from_u64(11);
+    let __v_19: G = G::from_u64(171);
+    let __v_20: G = G::from_u64(137);
+    let __v_21: G = G::from_u64(185);
+    let __v_22: G = G::from_u64(214);
+    let __v_23: G = G::from_u64(53);
+    let __v_24: G = G::from_u64(51);
+    let __v_25: G = G::from_u64(209);
+    let __v_26: G = G::from_u64(173);
+    let __v_27: G = G::from_u64(239);
+    let __v_28: G = G::from_u64(200);
+    let __v_29: G = G::from_u64(118);
+    let __v_30: G = G::from_u64(24);
+    let __v_31: G = G::from_u64(47);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_155] = [__v_32];
     record.function_queries[155].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17202,38 +17145,38 @@ fn aiur_fn_156(
   unconstrained: bool,
 ) -> Result<[G; OUT_156], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(212);
-    let __v_1: G = G::from_u64(53);
-    let __v_2: G = G::from_u64(161);
-    let __v_3: G = G::from_u64(94);
-    let __v_4: G = G::from_u64(111);
-    let __v_5: G = G::from_u64(34);
-    let __v_6: G = G::from_u64(47);
-    let __v_7: G = G::from_u64(120);
-    let __v_8: G = G::from_u64(107);
-    let __v_9: G = G::from_u64(97);
-    let __v_10: G = G::from_u64(48);
-    let __v_11: G = G::from_u64(250);
-    let __v_12: G = G::from_u64(118);
-    let __v_13: G = G::from_u64(76);
-    let __v_14: G = G::from_u64(127);
-    let __v_15: G = G::from_u64(190);
-    let __v_16: G = G::from_u64(152);
-    let __v_17: G = G::from_u64(116);
-    let __v_18: G = G::from_u64(111);
-    let __v_19: G = G::from_u64(121);
-    let __v_20: G = G::from_u64(142);
-    let __v_21: G = G::from_u64(151);
-    let __v_22: G = G::from_u64(166);
-    let __v_23: G = G::from_u64(39);
-    let __v_24: G = G::from_u64(166);
-    let __v_25: G = G::from_u64(35);
-    let __v_26: G = G::from_u64(122);
-    let __v_27: G = G::from_u64(23);
-    let __v_28: G = G::from_u64(231);
-    let __v_29: G = G::from_u64(79);
-    let __v_30: G = G::from_u64(114);
-    let __v_31: G = G::from_u64(39);
+    let __v_0: G = G::from_u64(247);
+    let __v_1: G = G::from_u64(19);
+    let __v_2: G = G::from_u64(13);
+    let __v_3: G = G::from_u64(88);
+    let __v_4: G = G::from_u64(100);
+    let __v_5: G = G::from_u64(225);
+    let __v_6: G = G::from_u64(186);
+    let __v_7: G = G::from_u64(119);
+    let __v_8: G = G::from_u64(176);
+    let __v_9: G = G::from_u64(246);
+    let __v_10: G = G::from_u64(167);
+    let __v_11: G = G::from_u64(51);
+    let __v_12: G = G::from_u64(143);
+    let __v_13: G = G::from_u64(146);
+    let __v_14: G = G::from_u64(21);
+    let __v_15: G = G::from_u64(156);
+    let __v_16: G = G::from_u64(53);
+    let __v_17: G = G::from_u64(189);
+    let __v_18: G = G::from_u64(81);
+    let __v_19: G = G::from_u64(71);
+    let __v_20: G = G::from_u64(224);
+    let __v_21: G = G::from_u64(254);
+    let __v_22: G = G::from_u64(188);
+    let __v_23: G = G::from_u64(241);
+    let __v_24: G = G::from_u64(235);
+    let __v_25: G = G::from_u64(237);
+    let __v_26: G = G::from_u64(69);
+    let __v_27: G = G::from_u64(110);
+    let __v_28: G = G::from_u64(81);
+    let __v_29: G = G::from_u64(53);
+    let __v_30: G = G::from_u64(56);
+    let __v_31: G = G::from_u64(204);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_156] = [__v_32];
     record.function_queries[156].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17251,38 +17194,38 @@ fn aiur_fn_157(
   unconstrained: bool,
 ) -> Result<[G; OUT_157], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(62);
-    let __v_1: G = G::from_u64(19);
-    let __v_2: G = G::from_u64(252);
-    let __v_3: G = G::from_u64(26);
-    let __v_4: G = G::from_u64(7);
-    let __v_5: G = G::from_u64(126);
-    let __v_6: G = G::from_u64(182);
-    let __v_7: G = G::from_u64(146);
-    let __v_8: G = G::from_u64(175);
-    let __v_9: G = G::from_u64(64);
-    let __v_10: G = G::from_u64(172);
-    let __v_11: G = G::from_u64(190);
-    let __v_12: G = G::from_u64(212);
-    let __v_13: G = G::from_u64(166);
-    let __v_14: G = G::from_u64(173);
-    let __v_15: G = G::from_u64(174);
-    let __v_16: G = G::from_u64(37);
-    let __v_17: G = G::from_u64(92);
-    let __v_18: G = G::from_u64(12);
-    let __v_19: G = G::from_u64(187);
-    let __v_20: G = G::from_u64(186);
-    let __v_21: G = G::from_u64(154);
-    let __v_22: G = G::from_u64(60);
-    let __v_23: G = G::from_u64(31);
-    let __v_24: G = G::from_u64(13);
-    let __v_25: G = G::from_u64(226);
-    let __v_26: G = G::from_u64(149);
-    let __v_27: G = G::from_u64(115);
-    let __v_28: G = G::from_u64(177);
-    let __v_29: G = G::from_u64(151);
-    let __v_30: G = G::from_u64(203);
-    let __v_31: G = G::from_u64(14);
+    let __v_0: G = G::from_u64(157);
+    let __v_1: G = G::from_u64(176);
+    let __v_2: G = G::from_u64(23);
+    let __v_3: G = G::from_u64(126);
+    let __v_4: G = G::from_u64(78);
+    let __v_5: G = G::from_u64(139);
+    let __v_6: G = G::from_u64(106);
+    let __v_7: G = G::from_u64(14);
+    let __v_8: G = G::from_u64(115);
+    let __v_9: G = G::from_u64(35);
+    let __v_10: G = G::from_u64(6);
+    let __v_11: G = G::from_u64(149);
+    let __v_12: G = G::from_u64(9);
+    let __v_13: G = G::from_u64(194);
+    let __v_14: G = G::from_u64(69);
+    let __v_15: G = G::from_u64(125);
+    let __v_16: G = G::from_u64(233);
+    let __v_17: G = G::from_u64(89);
+    let __v_18: G = G::from_u64(138);
+    let __v_19: G = G::from_u64(126);
+    let __v_20: G = G::from_u64(56);
+    let __v_21: G = G::from_u64(231);
+    let __v_22: G = G::from_u64(47);
+    let __v_23: G = G::from_u64(254);
+    let __v_24: G = G::from_u64(25);
+    let __v_25: G = G::from_u64(173);
+    let __v_26: G = G::from_u64(52);
+    let __v_27: G = G::from_u64(97);
+    let __v_28: G = G::from_u64(114);
+    let __v_29: G = G::from_u64(86);
+    let __v_30: G = G::from_u64(225);
+    let __v_31: G = G::from_u64(13);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_157] = [__v_32];
     record.function_queries[157].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17300,38 +17243,38 @@ fn aiur_fn_158(
   unconstrained: bool,
 ) -> Result<[G; OUT_158], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(153);
-    let __v_1: G = G::from_u64(112);
-    let __v_2: G = G::from_u64(244);
-    let __v_3: G = G::from_u64(2);
-    let __v_4: G = G::from_u64(200);
-    let __v_5: G = G::from_u64(112);
-    let __v_6: G = G::from_u64(232);
-    let __v_7: G = G::from_u64(163);
-    let __v_8: G = G::from_u64(20);
-    let __v_9: G = G::from_u64(111);
-    let __v_10: G = G::from_u64(191);
-    let __v_11: G = G::from_u64(75);
-    let __v_12: G = G::from_u64(118);
-    let __v_13: G = G::from_u64(249);
-    let __v_14: G = G::from_u64(73);
-    let __v_15: G = G::from_u64(170);
-    let __v_16: G = G::from_u64(100);
-    let __v_17: G = G::from_u64(178);
-    let __v_18: G = G::from_u64(6);
-    let __v_19: G = G::from_u64(222);
-    let __v_20: G = G::from_u64(155);
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = G::from_u64(87);
-    let __v_23: G = G::from_u64(180);
-    let __v_24: G = G::from_u64(105);
-    let __v_25: G = G::from_u64(253);
-    let __v_26: G = G::from_u64(227);
-    let __v_27: G = G::from_u64(87);
-    let __v_28: G = G::from_u64(183);
-    let __v_29: G = G::from_u64(21);
-    let __v_30: G = G::from_u64(241);
-    let __v_31: G = G::from_u64(156);
+    let __v_0: G = G::from_u64(133);
+    let __v_1: G = G::from_u64(98);
+    let __v_2: G = G::from_u64(19);
+    let __v_3: G = G::from_u64(135);
+    let __v_4: G = G::from_u64(239);
+    let __v_5: G = G::from_u64(48);
+    let __v_6: G = G::from_u64(39);
+    let __v_7: G = G::from_u64(2);
+    let __v_8: G = G::from_u64(141);
+    let __v_9: G = G::from_u64(131);
+    let __v_10: G = G::from_u64(82);
+    let __v_11: G = G::from_u64(135);
+    let __v_12: G = G::from_u64(243);
+    let __v_13: G = G::from_u64(204);
+    let __v_14: G = G::from_u64(20);
+    let __v_15: G = G::from_u64(97);
+    let __v_16: G = G::from_u64(239);
+    let __v_17: G = G::from_u64(4);
+    let __v_18: G = G::from_u64(29);
+    let __v_19: G = G::from_u64(239);
+    let __v_20: G = G::from_u64(31);
+    let __v_21: G = G::from_u64(217);
+    let __v_22: G = G::from_u64(30);
+    let __v_23: G = G::from_u64(40);
+    let __v_24: G = G::from_u64(232);
+    let __v_25: G = G::from_u64(127);
+    let __v_26: G = G::from_u64(102);
+    let __v_27: G = G::from_u64(156);
+    let __v_28: G = G::from_u64(192);
+    let __v_29: G = G::from_u64(74);
+    let __v_30: G = G::from_u64(94);
+    let __v_31: G = G::from_u64(234);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_158] = [__v_32];
     record.function_queries[158].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17349,38 +17292,38 @@ fn aiur_fn_159(
   unconstrained: bool,
 ) -> Result<[G; OUT_159], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(134);
-    let __v_1: G = G::from_u64(127);
-    let __v_2: G = G::from_u64(142);
-    let __v_3: G = G::from_u64(157);
-    let __v_4: G = G::from_u64(251);
-    let __v_5: G = G::from_u64(117);
-    let __v_6: G = G::from_u64(34);
-    let __v_7: G = G::from_u64(101);
-    let __v_8: G = G::from_u64(186);
-    let __v_9: G = G::from_u64(71);
-    let __v_10: G = G::from_u64(66);
-    let __v_11: G = G::from_u64(54);
-    let __v_12: G = G::from_u64(139);
-    let __v_13: G = G::from_u64(106);
-    let __v_14: G = G::from_u64(250);
-    let __v_15: G = G::from_u64(84);
-    let __v_16: G = G::from_u64(106);
-    let __v_17: G = G::from_u64(228);
-    let __v_18: G = G::from_u64(226);
-    let __v_19: G = G::from_u64(64);
-    let __v_20: G = G::from_u64(252);
-    let __v_21: G = G::from_u64(90);
-    let __v_22: G = G::from_u64(198);
-    let __v_23: G = G::from_u64(155);
-    let __v_24: G = G::from_u64(74);
-    let __v_25: G = G::from_u64(78);
-    let __v_26: G = G::from_u64(134);
-    let __v_27: G = G::from_u64(216);
-    let __v_28: G = G::from_u64(90);
-    let __v_29: G = G::from_u64(110);
-    let __v_30: G = G::from_u64(70);
-    let __v_31: G = G::from_u64(246);
+    let __v_0: G = G::from_u64(176);
+    let __v_1: G = G::from_u64(84);
+    let __v_2: G = G::from_u64(89);
+    let __v_3: G = G::from_u64(98);
+    let __v_4: G = G::from_u64(61);
+    let __v_5: G = G::from_u64(35);
+    let __v_6: G = G::from_u64(41);
+    let __v_7: G = G::from_u64(157);
+    let __v_8: G = G::from_u64(58);
+    let __v_9: G = G::from_u64(132);
+    let __v_10: G = G::from_u64(158);
+    let __v_11: G = G::from_u64(183);
+    let __v_12: G = G::from_u64(251);
+    let __v_13: G = G::from_u64(117);
+    let __v_14: G = G::from_u64(186);
+    let __v_15: G = G::from_u64(219);
+    let __v_16: G = G::from_u64(193);
+    let __v_17: G = G::from_u64(84);
+    let __v_18: G = G::from_u64(122);
+    let __v_19: G = G::from_u64(28);
+    let __v_20: G = G::from_u64(217);
+    let __v_21: G = G::from_u64(238);
+    let __v_22: G = G::from_u64(86);
+    let __v_23: G = G::from_u64(12);
+    let __v_24: G = G::from_u64(21);
+    let __v_25: G = G::from_u64(6);
+    let __v_26: G = G::from_u64(127);
+    let __v_27: G = G::from_u64(189);
+    let __v_28: G = G::from_u64(152);
+    let __v_29: G = G::from_u64(92);
+    let __v_30: G = G::from_u64(108);
+    let __v_31: G = G::from_u64(234);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_159] = [__v_32];
     record.function_queries[159].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17398,38 +17341,38 @@ fn aiur_fn_160(
   unconstrained: bool,
 ) -> Result<[G; OUT_160], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(33);
-    let __v_1: G = G::from_u64(212);
-    let __v_2: G = G::from_u64(218);
-    let __v_3: G = G::from_u64(204);
-    let __v_4: G = G::from_u64(15);
-    let __v_5: G = G::from_u64(64);
-    let __v_6: G = G::from_u64(107);
-    let __v_7: G = G::from_u64(49);
-    let __v_8: G = G::from_u64(224);
-    let __v_9: G = G::from_u64(68);
-    let __v_10: G = G::from_u64(251);
-    let __v_11: G = G::from_u64(244);
-    let __v_12: G = G::from_u64(216);
-    let __v_13: G = G::from_u64(152);
-    let __v_14: G = G::from_u64(122);
-    let __v_15: G = G::from_u64(51);
-    let __v_16: G = G::from_u64(45);
-    let __v_17: G = G::from_u64(216);
-    let __v_18: G = G::from_u64(180);
-    let __v_19: G = G::from_u64(36);
-    let __v_20: G = G::from_u64(79);
-    let __v_21: G = G::from_u64(125);
-    let __v_22: G = G::from_u64(158);
-    let __v_23: G = G::from_u64(98);
-    let __v_24: G = G::from_u64(176);
-    let __v_25: G = G::from_u64(134);
-    let __v_26: G = G::from_u64(80);
-    let __v_27: G = G::from_u64(20);
-    let __v_28: G = G::from_u64(116);
-    let __v_29: G = G::from_u64(130);
-    let __v_30: G = G::from_u64(85);
-    let __v_31: G = G::from_u64(68);
+    let __v_0: G = G::from_u64(103);
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(215);
+    let __v_3: G = G::from_u64(101);
+    let __v_4: G = G::from_u64(255);
+    let __v_5: G = G::from_u64(16);
+    let __v_6: G = G::from_u64(191);
+    let __v_7: G = G::from_u64(163);
+    let __v_8: G = G::from_u64(166);
+    let __v_9: G = G::from_u64(195);
+    let __v_10: G = G::from_u64(71);
+    let __v_11: G = G::from_u64(223);
+    let __v_12: G = G::from_u64(21);
+    let __v_13: G = G::from_u64(25);
+    let __v_14: G = G::from_u64(78);
+    let __v_15: G = G::from_u64(13);
+    let __v_16: G = G::from_u64(184);
+    let __v_17: G = G::from_u64(98);
+    let __v_18: G = G::from_u64(238);
+    let __v_19: G = G::from_u64(37);
+    let __v_20: G = G::from_u64(181);
+    let __v_21: G = G::from_u64(79);
+    let __v_22: G = G::from_u64(37);
+    let __v_23: G = G::from_u64(165);
+    let __v_24: G = G::from_u64(159);
+    let __v_25: G = G::from_u64(124);
+    let __v_26: G = G::from_u64(242);
+    let __v_27: G = G::from_u64(25);
+    let __v_28: G = G::from_u64(81);
+    let __v_29: G = G::from_u64(163);
+    let __v_30: G = G::from_u64(153);
+    let __v_31: G = G::from_u64(126);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_160] = [__v_32];
     record.function_queries[160].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17447,38 +17390,38 @@ fn aiur_fn_161(
   unconstrained: bool,
 ) -> Result<[G; OUT_161], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(135);
-    let __v_1: G = G::from_u64(133);
-    let __v_2: G = G::from_u64(153);
-    let __v_3: G = G::from_u64(233);
-    let __v_4: G = G::from_u64(245);
+    let __v_0: G = G::from_u64(226);
+    let __v_1: G = G::from_u64(156);
+    let __v_2: G = G::from_u64(250);
+    let __v_3: G = G::from_u64(121);
+    let __v_4: G = G::from_u64(33);
     let __v_5: G = G::from_u64(187);
-    let __v_6: G = G::from_u64(204);
-    let __v_7: G = G::from_u64(185);
-    let __v_8: G = G::from_u64(66);
-    let __v_9: G = G::from_u64(35);
-    let __v_10: G = G::from_u64(47);
-    let __v_11: G = G::from_u64(249);
-    let __v_12: G = G::from_u64(59);
-    let __v_13: G = G::from_u64(98);
-    let __v_14: G = G::from_u64(198);
-    let __v_15: G = G::from_u64(61);
-    let __v_16: G = G::from_u64(180);
-    let __v_17: G = G::from_u64(235);
-    let __v_18: G = G::from_u64(223);
-    let __v_19: G = G::from_u64(98);
-    let __v_20: G = G::from_u64(185);
-    let __v_21: G = G::from_u64(249);
-    let __v_22: G = G::from_u64(35);
-    let __v_23: G = G::from_u64(121);
-    let __v_24: G = G::from_u64(0);
-    let __v_25: G = G::from_u64(163);
-    let __v_26: G = G::from_u64(112);
-    let __v_27: G = G::from_u64(73);
-    let __v_28: G = G::from_u64(244);
-    let __v_29: G = G::from_u64(34);
-    let __v_30: G = G::from_u64(173);
-    let __v_31: G = G::from_u64(134);
+    let __v_6: G = G::from_u64(87);
+    let __v_7: G = G::from_u64(244);
+    let __v_8: G = G::from_u64(120);
+    let __v_9: G = G::from_u64(43);
+    let __v_10: G = G::from_u64(2);
+    let __v_11: G = G::from_u64(28);
+    let __v_12: G = G::from_u64(151);
+    let __v_13: G = G::from_u64(117);
+    let __v_14: G = G::from_u64(150);
+    let __v_15: G = G::from_u64(164);
+    let __v_16: G = G::from_u64(250);
+    let __v_17: G = G::from_u64(224);
+    let __v_18: G = G::from_u64(78);
+    let __v_19: G = G::from_u64(148);
+    let __v_20: G = G::from_u64(247);
+    let __v_21: G = G::from_u64(176);
+    let __v_22: G = G::from_u64(121);
+    let __v_23: G = G::from_u64(85);
+    let __v_24: G = G::from_u64(254);
+    let __v_25: G = G::from_u64(40);
+    let __v_26: G = G::from_u64(20);
+    let __v_27: G = G::from_u64(252);
+    let __v_28: G = G::from_u64(72);
+    let __v_29: G = G::from_u64(222);
+    let __v_30: G = G::from_u64(144);
+    let __v_31: G = G::from_u64(231);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_161] = [__v_32];
     record.function_queries[161].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17496,38 +17439,38 @@ fn aiur_fn_162(
   unconstrained: bool,
 ) -> Result<[G; OUT_162], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(249);
-    let __v_1: G = G::from_u64(172);
-    let __v_2: G = G::from_u64(146);
-    let __v_3: G = G::from_u64(161);
-    let __v_4: G = G::from_u64(19);
-    let __v_5: G = G::from_u64(136);
-    let __v_6: G = G::from_u64(167);
-    let __v_7: G = G::from_u64(205);
-    let __v_8: G = G::from_u64(202);
-    let __v_9: G = G::from_u64(34);
-    let __v_10: G = G::from_u64(154);
-    let __v_11: G = G::from_u64(128);
-    let __v_12: G = G::from_u64(36);
-    let __v_13: G = G::from_u64(32);
-    let __v_14: G = G::from_u64(133);
-    let __v_15: G = G::from_u64(84);
-    let __v_16: G = G::from_u64(254);
-    let __v_17: G = G::from_u64(179);
-    let __v_18: G = G::from_u64(45);
-    let __v_19: G = G::from_u64(108);
-    let __v_20: G = G::from_u64(10);
-    let __v_21: G = G::from_u64(58);
-    let __v_22: G = G::from_u64(247);
-    let __v_23: G = G::from_u64(74);
-    let __v_24: G = G::from_u64(123);
-    let __v_25: G = G::from_u64(193);
-    let __v_26: G = G::from_u64(44);
-    let __v_27: G = G::from_u64(40);
-    let __v_28: G = G::from_u64(185);
-    let __v_29: G = G::from_u64(73);
-    let __v_30: G = G::from_u64(84);
-    let __v_31: G = G::from_u64(60);
+    let __v_0: G = G::from_u64(156);
+    let __v_1: G = G::from_u64(149);
+    let __v_2: G = G::from_u64(45);
+    let __v_3: G = G::from_u64(69);
+    let __v_4: G = G::from_u64(163);
+    let __v_5: G = G::from_u64(189);
+    let __v_6: G = G::from_u64(67);
+    let __v_7: G = G::from_u64(22);
+    let __v_8: G = G::from_u64(21);
+    let __v_9: G = G::from_u64(41);
+    let __v_10: G = G::from_u64(252);
+    let __v_11: G = G::from_u64(251);
+    let __v_12: G = G::from_u64(94);
+    let __v_13: G = G::from_u64(39);
+    let __v_14: G = G::from_u64(107);
+    let __v_15: G = G::from_u64(234);
+    let __v_16: G = G::from_u64(176);
+    let __v_17: G = G::from_u64(207);
+    let __v_18: G = G::from_u64(79);
+    let __v_19: G = G::from_u64(214);
+    let __v_20: G = G::from_u64(74);
+    let __v_21: G = G::from_u64(1);
+    let __v_22: G = G::from_u64(186);
+    let __v_23: G = G::from_u64(155);
+    let __v_24: G = G::from_u64(194);
+    let __v_25: G = G::from_u64(199);
+    let __v_26: G = G::from_u64(205);
+    let __v_27: G = G::from_u64(163);
+    let __v_28: G = G::from_u64(118);
+    let __v_29: G = G::from_u64(203);
+    let __v_30: G = G::from_u64(143);
+    let __v_31: G = G::from_u64(84);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_162] = [__v_32];
     record.function_queries[162].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17545,38 +17488,38 @@ fn aiur_fn_163(
   unconstrained: bool,
 ) -> Result<[G; OUT_163], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(223);
-    let __v_1: G = G::from_u64(56);
-    let __v_2: G = G::from_u64(53);
-    let __v_3: G = G::from_u64(47);
-    let __v_4: G = G::from_u64(250);
-    let __v_5: G = G::from_u64(29);
-    let __v_6: G = G::from_u64(110);
-    let __v_7: G = G::from_u64(41);
-    let __v_8: G = G::from_u64(35);
-    let __v_9: G = G::from_u64(73);
-    let __v_10: G = G::from_u64(37);
-    let __v_11: G = G::from_u64(159);
-    let __v_12: G = G::from_u64(51);
-    let __v_13: G = G::from_u64(235);
-    let __v_14: G = G::from_u64(103);
-    let __v_15: G = G::from_u64(128);
-    let __v_16: G = G::from_u64(36);
-    let __v_17: G = G::from_u64(187);
-    let __v_18: G = G::from_u64(100);
-    let __v_19: G = G::from_u64(107);
-    let __v_20: G = G::from_u64(53);
-    let __v_21: G = G::from_u64(134);
-    let __v_22: G = G::from_u64(56);
-    let __v_23: G = G::from_u64(160);
-    let __v_24: G = G::from_u64(45);
-    let __v_25: G = G::from_u64(161);
-    let __v_26: G = G::from_u64(153);
-    let __v_27: G = G::from_u64(94);
-    let __v_28: G = G::from_u64(212);
-    let __v_29: G = G::from_u64(171);
-    let __v_30: G = G::from_u64(235);
-    let __v_31: G = G::from_u64(9);
+    let __v_0: G = G::from_u64(11);
+    let __v_1: G = G::from_u64(21);
+    let __v_2: G = G::from_u64(100);
+    let __v_3: G = G::from_u64(222);
+    let __v_4: G = G::from_u64(166);
+    let __v_5: G = G::from_u64(255);
+    let __v_6: G = G::from_u64(205);
+    let __v_7: G = G::from_u64(32);
+    let __v_8: G = G::from_u64(78);
+    let __v_9: G = G::from_u64(188);
+    let __v_10: G = G::from_u64(209);
+    let __v_11: G = G::from_u64(170);
+    let __v_12: G = G::from_u64(105);
+    let __v_13: G = G::from_u64(210);
+    let __v_14: G = G::from_u64(158);
+    let __v_15: G = G::from_u64(230);
+    let __v_16: G = G::from_u64(243);
+    let __v_17: G = G::from_u64(172);
+    let __v_18: G = G::from_u64(204);
+    let __v_19: G = G::from_u64(216);
+    let __v_20: G = G::from_u64(123);
+    let __v_21: G = G::from_u64(209);
+    let __v_22: G = G::from_u64(70);
+    let __v_23: G = G::from_u64(255);
+    let __v_24: G = G::from_u64(103);
+    let __v_25: G = G::from_u64(69);
+    let __v_26: G = G::from_u64(86);
+    let __v_27: G = G::from_u64(172);
+    let __v_28: G = G::from_u64(156);
+    let __v_29: G = G::from_u64(200);
+    let __v_30: G = G::from_u64(204);
+    let __v_31: G = G::from_u64(179);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_163] = [__v_32];
     record.function_queries[163].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17594,38 +17537,38 @@ fn aiur_fn_164(
   unconstrained: bool,
 ) -> Result<[G; OUT_164], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(243);
-    let __v_1: G = G::from_u64(141);
-    let __v_2: G = G::from_u64(79);
-    let __v_3: G = G::from_u64(123);
-    let __v_4: G = G::from_u64(170);
-    let __v_5: G = G::from_u64(160);
-    let __v_6: G = G::from_u64(33);
-    let __v_7: G = G::from_u64(227);
-    let __v_8: G = G::from_u64(181);
-    let __v_9: G = G::from_u64(85);
-    let __v_10: G = G::from_u64(49);
-    let __v_11: G = G::from_u64(33);
-    let __v_12: G = G::from_u64(69);
-    let __v_13: G = G::from_u64(217);
-    let __v_14: G = G::from_u64(255);
-    let __v_15: G = G::from_u64(211);
-    let __v_16: G = G::from_u64(221);
-    let __v_17: G = G::from_u64(197);
-    let __v_18: G = G::from_u64(234);
-    let __v_19: G = G::from_u64(203);
-    let __v_20: G = G::from_u64(123);
-    let __v_21: G = G::from_u64(253);
-    let __v_22: G = G::from_u64(91);
-    let __v_23: G = G::from_u64(134);
-    let __v_24: G = G::from_u64(167);
-    let __v_25: G = G::from_u64(176);
-    let __v_26: G = G::from_u64(234);
-    let __v_27: G = G::from_u64(253);
-    let __v_28: G = G::from_u64(252);
-    let __v_29: G = G::from_u64(244);
-    let __v_30: G = G::from_u64(22);
-    let __v_31: G = G::from_u64(170);
+    let __v_0: G = G::from_u64(109);
+    let __v_1: G = G::from_u64(53);
+    let __v_2: G = G::from_u64(220);
+    let __v_3: G = G::from_u64(67);
+    let __v_4: G = G::from_u64(102);
+    let __v_5: G = G::from_u64(15);
+    let __v_6: G = G::from_u64(108);
+    let __v_7: G = G::from_u64(80);
+    let __v_8: G = G::from_u64(154);
+    let __v_9: G = G::from_u64(19);
+    let __v_10: G = G::from_u64(242);
+    let __v_11: G = G::from_u64(130);
+    let __v_12: G = G::from_u64(76);
+    let __v_13: G = G::from_u64(2);
+    let __v_14: G = G::from_u64(126);
+    let __v_15: G = G::from_u64(217);
+    let __v_16: G = G::from_u64(154);
+    let __v_17: G = G::from_u64(176);
+    let __v_18: G = G::from_u64(112);
+    let __v_19: G = G::from_u64(160);
+    let __v_20: G = G::from_u64(143);
+    let __v_21: G = G::from_u64(5);
+    let __v_22: G = G::from_u64(143);
+    let __v_23: G = G::from_u64(240);
+    let __v_24: G = G::from_u64(165);
+    let __v_25: G = G::from_u64(244);
+    let __v_26: G = G::from_u64(106);
+    let __v_27: G = G::from_u64(117);
+    let __v_28: G = G::from_u64(146);
+    let __v_29: G = G::from_u64(80);
+    let __v_30: G = G::from_u64(121);
+    let __v_31: G = G::from_u64(125);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_164] = [__v_32];
     record.function_queries[164].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17643,38 +17586,38 @@ fn aiur_fn_165(
   unconstrained: bool,
 ) -> Result<[G; OUT_165], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(104);
-    let __v_1: G = G::from_u64(246);
-    let __v_2: G = G::from_u64(30);
-    let __v_3: G = G::from_u64(245);
-    let __v_4: G = G::from_u64(91);
-    let __v_5: G = G::from_u64(99);
-    let __v_6: G = G::from_u64(205);
-    let __v_7: G = G::from_u64(35);
-    let __v_8: G = G::from_u64(173);
-    let __v_9: G = G::from_u64(142);
-    let __v_10: G = G::from_u64(209);
-    let __v_11: G = G::from_u64(133);
-    let __v_12: G = G::from_u64(183);
-    let __v_13: G = G::from_u64(238);
-    let __v_14: G = G::from_u64(195);
-    let __v_15: G = G::from_u64(220);
-    let __v_16: G = G::from_u64(117);
-    let __v_17: G = G::from_u64(78);
-    let __v_18: G = G::from_u64(97);
-    let __v_19: G = G::from_u64(204);
-    let __v_20: G = G::from_u64(88);
-    let __v_21: G = G::from_u64(5);
-    let __v_22: G = G::from_u64(96);
-    let __v_23: G = G::from_u64(135);
-    let __v_24: G = G::from_u64(169);
-    let __v_25: G = G::from_u64(126);
-    let __v_26: G = G::from_u64(129);
-    let __v_27: G = G::from_u64(157);
-    let __v_28: G = G::from_u64(14);
-    let __v_29: G = G::from_u64(149);
-    let __v_30: G = G::from_u64(230);
-    let __v_31: G = G::from_u64(253);
+    let __v_0: G = G::from_u64(38);
+    let __v_1: G = G::from_u64(26);
+    let __v_2: G = G::from_u64(229);
+    let __v_3: G = G::from_u64(78);
+    let __v_4: G = G::from_u64(219);
+    let __v_5: G = G::from_u64(102);
+    let __v_6: G = G::from_u64(233);
+    let __v_7: G = G::from_u64(0);
+    let __v_8: G = G::from_u64(120);
+    let __v_9: G = G::from_u64(74);
+    let __v_10: G = G::from_u64(100);
+    let __v_11: G = G::from_u64(53);
+    let __v_12: G = G::from_u64(11);
+    let __v_13: G = G::from_u64(192);
+    let __v_14: G = G::from_u64(30);
+    let __v_15: G = G::from_u64(139);
+    let __v_16: G = G::from_u64(63);
+    let __v_17: G = G::from_u64(225);
+    let __v_18: G = G::from_u64(51);
+    let __v_19: G = G::from_u64(42);
+    let __v_20: G = G::from_u64(71);
+    let __v_21: G = G::from_u64(202);
+    let __v_22: G = G::from_u64(234);
+    let __v_23: G = G::from_u64(181);
+    let __v_24: G = G::from_u64(142);
+    let __v_25: G = G::from_u64(3);
+    let __v_26: G = G::from_u64(97);
+    let __v_27: G = G::from_u64(223);
+    let __v_28: G = G::from_u64(252);
+    let __v_29: G = G::from_u64(126);
+    let __v_30: G = G::from_u64(160);
+    let __v_31: G = G::from_u64(8);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_165] = [__v_32];
     record.function_queries[165].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17692,38 +17635,38 @@ fn aiur_fn_166(
   unconstrained: bool,
 ) -> Result<[G; OUT_166], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(173);
-    let __v_1: G = G::from_u64(71);
-    let __v_2: G = G::from_u64(242);
-    let __v_3: G = G::from_u64(187);
-    let __v_4: G = G::from_u64(232);
-    let __v_5: G = G::from_u64(145);
-    let __v_6: G = G::from_u64(184);
-    let __v_7: G = G::from_u64(37);
-    let __v_8: G = G::from_u64(196);
-    let __v_9: G = G::from_u64(138);
-    let __v_10: G = G::from_u64(39);
-    let __v_11: G = G::from_u64(143);
-    let __v_12: G = G::from_u64(154);
-    let __v_13: G = G::from_u64(13);
-    let __v_14: G = G::from_u64(114);
-    let __v_15: G = G::from_u64(153);
-    let __v_16: G = G::from_u64(123);
-    let __v_17: G = G::from_u64(120);
-    let __v_18: G = G::from_u64(186);
-    let __v_19: G = G::from_u64(172);
-    let __v_20: G = G::from_u64(121);
-    let __v_21: G = G::from_u64(137);
-    let __v_22: G = G::from_u64(28);
-    let __v_23: G = G::from_u64(166);
-    let __v_24: G = G::from_u64(101);
-    let __v_25: G = G::from_u64(25);
-    let __v_26: G = G::from_u64(136);
-    let __v_27: G = G::from_u64(183);
-    let __v_28: G = G::from_u64(201);
-    let __v_29: G = G::from_u64(180);
-    let __v_30: G = G::from_u64(127);
-    let __v_31: G = G::from_u64(3);
+    let __v_0: G = G::from_u64(135);
+    let __v_1: G = G::from_u64(38);
+    let __v_2: G = G::from_u64(100);
+    let __v_3: G = G::from_u64(21);
+    let __v_4: G = G::from_u64(152);
+    let __v_5: G = G::from_u64(43);
+    let __v_6: G = G::from_u64(189);
+    let __v_7: G = G::from_u64(236);
+    let __v_8: G = G::from_u64(80);
+    let __v_9: G = G::from_u64(198);
+    let __v_10: G = G::from_u64(29);
+    let __v_11: G = G::from_u64(236);
+    let __v_12: G = G::from_u64(91);
+    let __v_13: G = G::from_u64(115);
+    let __v_14: G = G::from_u64(204);
+    let __v_15: G = G::from_u64(12);
+    let __v_16: G = G::from_u64(205);
+    let __v_17: G = G::from_u64(92);
+    let __v_18: G = G::from_u64(153);
+    let __v_19: G = G::from_u64(116);
+    let __v_20: G = G::from_u64(69);
+    let __v_21: G = G::from_u64(153);
+    let __v_22: G = G::from_u64(122);
+    let __v_23: G = G::from_u64(151);
+    let __v_24: G = G::from_u64(36);
+    let __v_25: G = G::from_u64(161);
+    let __v_26: G = G::from_u64(204);
+    let __v_27: G = G::from_u64(92);
+    let __v_28: G = G::from_u64(46);
+    let __v_29: G = G::from_u64(57);
+    let __v_30: G = G::from_u64(211);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_166] = [__v_32];
     record.function_queries[166].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17741,38 +17684,38 @@ fn aiur_fn_167(
   unconstrained: bool,
 ) -> Result<[G; OUT_167], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(246);
-    let __v_1: G = G::from_u64(235);
-    let __v_2: G = G::from_u64(116);
-    let __v_3: G = G::from_u64(41);
-    let __v_4: G = G::from_u64(150);
-    let __v_5: G = G::from_u64(198);
-    let __v_6: G = G::from_u64(15);
-    let __v_7: G = G::from_u64(16);
-    let __v_8: G = G::from_u64(104);
-    let __v_9: G = G::from_u64(194);
-    let __v_10: G = G::from_u64(212);
-    let __v_11: G = G::from_u64(55);
-    let __v_12: G = G::from_u64(175);
-    let __v_13: G = G::from_u64(221);
-    let __v_14: G = G::from_u64(139);
-    let __v_15: G = G::from_u64(54);
-    let __v_16: G = G::from_u64(9);
-    let __v_17: G = G::from_u64(4);
-    let __v_18: G = G::from_u64(13);
-    let __v_19: G = G::from_u64(100);
-    let __v_20: G = G::from_u64(238);
-    let __v_21: G = G::from_u64(197);
-    let __v_22: G = G::from_u64(225);
-    let __v_23: G = G::from_u64(95);
-    let __v_24: G = G::from_u64(7);
-    let __v_25: G = G::from_u64(161);
-    let __v_26: G = G::from_u64(29);
-    let __v_27: G = G::from_u64(193);
-    let __v_28: G = G::from_u64(29);
-    let __v_29: G = G::from_u64(7);
-    let __v_30: G = G::from_u64(13);
-    let __v_31: G = G::from_u64(123);
+    let __v_0: G = G::from_u64(114);
+    let __v_1: G = G::from_u64(77);
+    let __v_2: G = G::from_u64(183);
+    let __v_3: G = G::from_u64(151);
+    let __v_4: G = G::from_u64(225);
+    let __v_5: G = G::from_u64(129);
+    let __v_6: G = G::from_u64(117);
+    let __v_7: G = G::from_u64(69);
+    let __v_8: G = G::from_u64(160);
+    let __v_9: G = G::from_u64(131);
+    let __v_10: G = G::from_u64(113);
+    let __v_11: G = G::from_u64(67);
+    let __v_12: G = G::from_u64(47);
+    let __v_13: G = G::from_u64(209);
+    let __v_14: G = G::from_u64(250);
+    let __v_15: G = G::from_u64(100);
+    let __v_16: G = G::from_u64(40);
+    let __v_17: G = G::from_u64(163);
+    let __v_18: G = G::from_u64(125);
+    let __v_19: G = G::from_u64(207);
+    let __v_20: G = G::from_u64(156);
+    let __v_21: G = G::from_u64(22);
+    let __v_22: G = G::from_u64(113);
+    let __v_23: G = G::from_u64(223);
+    let __v_24: G = G::from_u64(126);
+    let __v_25: G = G::from_u64(70);
+    let __v_26: G = G::from_u64(72);
+    let __v_27: G = G::from_u64(73);
+    let __v_28: G = G::from_u64(219);
+    let __v_29: G = G::from_u64(10);
+    let __v_30: G = G::from_u64(129);
+    let __v_31: G = G::from_u64(172);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_167] = [__v_32];
     record.function_queries[167].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17790,38 +17733,38 @@ 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(35);
-    let __v_1: G = G::from_u64(23);
-    let __v_2: G = G::from_u64(54);
-    let __v_3: G = G::from_u64(73);
-    let __v_4: G = G::from_u64(165);
-    let __v_5: G = G::from_u64(142);
-    let __v_6: G = G::from_u64(165);
-    let __v_7: G = G::from_u64(9);
-    let __v_8: G = G::from_u64(93);
-    let __v_9: G = G::from_u64(28);
-    let __v_10: G = G::from_u64(81);
-    let __v_11: G = G::from_u64(162);
-    let __v_12: G = G::from_u64(28);
-    let __v_13: G = G::from_u64(122);
-    let __v_14: G = G::from_u64(210);
-    let __v_15: G = G::from_u64(207);
-    let __v_16: G = G::from_u64(142);
-    let __v_17: G = G::from_u64(141);
-    let __v_18: G = G::from_u64(204);
-    let __v_19: G = G::from_u64(239);
-    let __v_20: G = G::from_u64(52);
-    let __v_21: G = G::from_u64(38);
-    let __v_22: G = G::from_u64(152);
-    let __v_23: G = G::from_u64(224);
-    let __v_24: G = G::from_u64(126);
-    let __v_25: G = G::from_u64(36);
-    let __v_26: G = G::from_u64(22);
-    let __v_27: G = G::from_u64(104);
-    let __v_28: G = G::from_u64(255);
-    let __v_29: G = G::from_u64(122);
-    let __v_30: G = G::from_u64(211);
-    let __v_31: G = G::from_u64(231);
+    let __v_0: G = G::from_u64(157);
+    let __v_1: G = G::from_u64(226);
+    let __v_2: G = G::from_u64(210);
+    let __v_3: G = G::from_u64(198);
+    let __v_4: G = G::from_u64(14);
+    let __v_5: G = G::from_u64(125);
+    let __v_6: G = G::from_u64(66);
+    let __v_7: G = G::from_u64(26);
+    let __v_8: G = G::from_u64(47);
+    let __v_9: G = G::from_u64(223);
+    let __v_10: G = G::from_u64(184);
+    let __v_11: G = G::from_u64(112);
+    let __v_12: G = G::from_u64(110);
+    let __v_13: G = G::from_u64(145);
+    let __v_14: G = G::from_u64(224);
+    let __v_15: G = G::from_u64(230);
+    let __v_16: G = G::from_u64(216);
+    let __v_17: G = G::from_u64(87);
+    let __v_18: G = G::from_u64(108);
+    let __v_19: G = G::from_u64(59);
+    let __v_20: G = G::from_u64(212);
+    let __v_21: G = G::from_u64(110);
+    let __v_22: G = G::from_u64(192);
+    let __v_23: G = G::from_u64(4);
+    let __v_24: G = G::from_u64(5);
+    let __v_25: G = G::from_u64(198);
+    let __v_26: G = G::from_u64(88);
+    let __v_27: G = G::from_u64(117);
+    let __v_28: G = G::from_u64(203);
+    let __v_29: G = G::from_u64(155);
+    let __v_30: G = G::from_u64(90);
+    let __v_31: G = G::from_u64(38);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_168] = [__v_32];
     record.function_queries[168].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17839,38 +17782,38 @@ 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(143);
-    let __v_1: G = G::from_u64(71);
-    let __v_2: G = G::from_u64(92);
-    let __v_3: G = G::from_u64(199);
-    let __v_4: G = G::from_u64(45);
-    let __v_5: G = G::from_u64(162);
-    let __v_6: G = G::from_u64(172);
-    let __v_7: G = G::from_u64(108);
-    let __v_8: G = G::from_u64(226);
-    let __v_9: G = G::from_u64(169);
-    let __v_10: G = G::from_u64(40);
-    let __v_11: G = G::from_u64(43);
-    let __v_12: G = G::from_u64(107);
-    let __v_13: G = G::from_u64(93);
-    let __v_14: G = G::from_u64(244);
-    let __v_15: G = G::from_u64(204);
-    let __v_16: G = G::from_u64(247);
-    let __v_17: G = G::from_u64(188);
-    let __v_18: G = G::from_u64(60);
-    let __v_19: G = G::from_u64(238);
-    let __v_20: G = G::from_u64(6);
-    let __v_21: G = G::from_u64(73);
-    let __v_22: G = G::from_u64(210);
-    let __v_23: G = G::from_u64(39);
-    let __v_24: G = G::from_u64(102);
-    let __v_25: G = G::from_u64(190);
-    let __v_26: G = G::from_u64(189);
-    let __v_27: G = G::from_u64(50);
-    let __v_28: G = G::from_u64(209);
-    let __v_29: G = G::from_u64(128);
-    let __v_30: G = G::from_u64(111);
-    let __v_31: G = G::from_u64(59);
+    let __v_0: G = G::from_u64(86);
+    let __v_1: G = G::from_u64(106);
+    let __v_2: G = G::from_u64(60);
+    let __v_3: G = G::from_u64(34);
+    let __v_4: G = G::from_u64(73);
+    let __v_5: G = G::from_u64(188);
+    let __v_6: G = G::from_u64(32);
+    let __v_7: G = G::from_u64(118);
+    let __v_8: G = G::from_u64(84);
+    let __v_9: G = G::from_u64(61);
+    let __v_10: G = G::from_u64(155);
+    let __v_11: G = G::from_u64(197);
+    let __v_12: G = G::from_u64(97);
+    let __v_13: G = G::from_u64(168);
+    let __v_14: G = G::from_u64(65);
+    let __v_15: G = G::from_u64(246);
+    let __v_16: G = G::from_u64(253);
+    let __v_17: G = G::from_u64(53);
+    let __v_18: G = G::from_u64(255);
+    let __v_19: G = G::from_u64(181);
+    let __v_20: G = G::from_u64(189);
+    let __v_21: G = G::from_u64(187);
+    let __v_22: G = G::from_u64(197);
+    let __v_23: G = G::from_u64(201);
+    let __v_24: G = G::from_u64(145);
+    let __v_25: G = G::from_u64(169);
+    let __v_26: G = G::from_u64(198);
+    let __v_27: G = G::from_u64(79);
+    let __v_28: G = G::from_u64(236);
+    let __v_29: G = G::from_u64(203);
+    let __v_30: G = G::from_u64(213);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_169] = [__v_32];
     record.function_queries[169].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17888,38 +17831,38 @@ fn aiur_fn_170(
   unconstrained: bool,
 ) -> Result<[G; OUT_170], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(143);
-    let __v_1: G = G::from_u64(60);
-    let __v_2: G = G::from_u64(28);
-    let __v_3: G = G::from_u64(67);
-    let __v_4: G = G::from_u64(44);
-    let __v_5: G = G::from_u64(89);
-    let __v_6: G = G::from_u64(142);
-    let __v_7: G = G::from_u64(66);
-    let __v_8: G = G::from_u64(64);
-    let __v_9: G = G::from_u64(211);
-    let __v_10: G = G::from_u64(111);
-    let __v_11: G = G::from_u64(137);
-    let __v_12: G = G::from_u64(69);
-    let __v_13: G = G::from_u64(148);
-    let __v_14: G = G::from_u64(33);
-    let __v_15: G = G::from_u64(116);
-    let __v_16: G = G::from_u64(103);
-    let __v_17: G = G::from_u64(92);
-    let __v_18: G = G::from_u64(92);
-    let __v_19: G = G::from_u64(145);
-    let __v_20: G = G::from_u64(224);
-    let __v_21: G = G::from_u64(63);
-    let __v_22: G = G::from_u64(107);
-    let __v_23: G = G::from_u64(138);
-    let __v_24: G = G::from_u64(176);
-    let __v_25: G = G::from_u64(24);
-    let __v_26: G = G::from_u64(232);
-    let __v_27: G = G::from_u64(176);
-    let __v_28: G = G::from_u64(82);
-    let __v_29: G = G::from_u64(98);
-    let __v_30: G = G::from_u64(44);
-    let __v_31: G = G::from_u64(99);
+    let __v_0: G = G::from_u64(91);
+    let __v_1: G = G::from_u64(164);
+    let __v_2: G = G::from_u64(58);
+    let __v_3: G = G::from_u64(195);
+    let __v_4: G = G::from_u64(229);
+    let __v_5: G = G::from_u64(210);
+    let __v_6: G = G::from_u64(159);
+    let __v_7: G = G::from_u64(229);
+    let __v_8: G = G::from_u64(206);
+    let __v_9: G = G::from_u64(129);
+    let __v_10: G = G::from_u64(241);
+    let __v_11: G = G::from_u64(138);
+    let __v_12: G = G::from_u64(24);
+    let __v_13: G = G::from_u64(23);
+    let __v_14: G = G::from_u64(138);
+    let __v_15: G = G::from_u64(39);
+    let __v_16: G = G::from_u64(5);
+    let __v_17: G = G::from_u64(195);
+    let __v_18: G = G::from_u64(126);
+    let __v_19: G = G::from_u64(230);
+    let __v_20: G = G::from_u64(116);
+    let __v_21: G = G::from_u64(185);
+    let __v_22: G = G::from_u64(182);
+    let __v_23: G = G::from_u64(238);
+    let __v_24: G = G::from_u64(80);
+    let __v_25: G = G::from_u64(233);
+    let __v_26: G = G::from_u64(70);
+    let __v_27: G = G::from_u64(106);
+    let __v_28: G = G::from_u64(134);
+    let __v_29: G = G::from_u64(89);
+    let __v_30: G = G::from_u64(59);
+    let __v_31: G = G::from_u64(21);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_170] = [__v_32];
     record.function_queries[170].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17937,38 +17880,38 @@ fn aiur_fn_171(
   unconstrained: bool,
 ) -> Result<[G; OUT_171], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(128);
-    let __v_1: G = G::from_u64(10);
-    let __v_2: G = G::from_u64(138);
-    let __v_3: G = G::from_u64(45);
-    let __v_4: G = G::from_u64(111);
-    let __v_5: G = G::from_u64(145);
-    let __v_6: G = G::from_u64(189);
-    let __v_7: G = G::from_u64(26);
-    let __v_8: G = G::from_u64(145);
-    let __v_9: G = G::from_u64(211);
-    let __v_10: G = G::from_u64(19);
-    let __v_11: G = G::from_u64(209);
-    let __v_12: G = G::from_u64(225);
-    let __v_13: G = G::from_u64(158);
-    let __v_14: G = G::from_u64(246);
-    let __v_15: G = G::from_u64(159);
-    let __v_16: G = G::from_u64(55);
-    let __v_17: G = G::from_u64(222);
-    let __v_18: G = G::from_u64(221);
-    let __v_19: G = G::from_u64(7);
-    let __v_20: G = G::from_u64(247);
-    let __v_21: G = G::from_u64(222);
-    let __v_22: G = G::from_u64(79);
-    let __v_23: G = G::from_u64(146);
-    let __v_24: G = G::from_u64(151);
-    let __v_25: G = G::from_u64(128);
-    let __v_26: G = G::from_u64(190);
-    let __v_27: G = G::from_u64(133);
-    let __v_28: G = G::from_u64(90);
-    let __v_29: G = G::from_u64(3);
-    let __v_30: G = G::from_u64(253);
-    let __v_31: G = G::from_u64(31);
+    let __v_0: G = G::from_u64(118);
+    let __v_1: G = G::from_u64(0);
+    let __v_2: G = G::from_u64(125);
+    let __v_3: G = G::from_u64(207);
+    let __v_4: G = G::from_u64(139);
+    let __v_5: G = G::from_u64(40);
+    let __v_6: G = G::from_u64(92);
+    let __v_7: G = G::from_u64(219);
+    let __v_8: G = G::from_u64(214);
+    let __v_9: G = G::from_u64(247);
+    let __v_10: G = G::from_u64(121);
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = G::from_u64(34);
+    let __v_13: G = G::from_u64(144);
+    let __v_14: G = G::from_u64(254);
+    let __v_15: G = G::from_u64(46);
+    let __v_16: G = G::from_u64(106);
+    let __v_17: G = G::from_u64(253);
+    let __v_18: G = G::from_u64(34);
+    let __v_19: G = G::from_u64(28);
+    let __v_20: G = G::from_u64(232);
+    let __v_21: G = G::from_u64(130);
+    let __v_22: G = G::from_u64(16);
+    let __v_23: G = G::from_u64(130);
+    let __v_24: G = G::from_u64(167);
+    let __v_25: G = G::from_u64(226);
+    let __v_26: G = G::from_u64(239);
+    let __v_27: G = G::from_u64(129);
+    let __v_28: G = G::from_u64(232);
+    let __v_29: G = G::from_u64(216);
+    let __v_30: G = G::from_u64(21);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_171] = [__v_32];
     record.function_queries[171].finish(&inp[..], &__ret[..], !unconstrained);
@@ -17986,38 +17929,38 @@ fn aiur_fn_172(
   unconstrained: bool,
 ) -> Result<[G; OUT_172], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(84);
-    let __v_1: G = G::from_u64(115);
-    let __v_2: G = G::from_u64(89);
-    let __v_3: G = G::from_u64(46);
-    let __v_4: G = G::from_u64(112);
-    let __v_5: G = G::from_u64(121);
-    let __v_6: G = G::from_u64(67);
-    let __v_7: G = G::from_u64(236);
-    let __v_8: G = G::from_u64(7);
-    let __v_9: G = G::from_u64(42);
-    let __v_10: G = G::from_u64(46);
-    let __v_11: G = G::from_u64(229);
-    let __v_12: G = G::from_u64(60);
-    let __v_13: G = G::from_u64(67);
-    let __v_14: G = G::from_u64(61);
-    let __v_15: G = G::from_u64(162);
-    let __v_16: G = G::from_u64(199);
-    let __v_17: G = G::from_u64(122);
-    let __v_18: G = G::from_u64(164);
-    let __v_19: G = G::from_u64(94);
-    let __v_20: G = G::from_u64(214);
-    let __v_21: G = G::from_u64(52);
-    let __v_22: G = G::from_u64(218);
-    let __v_23: G = G::from_u64(84);
-    let __v_24: G = G::from_u64(178);
-    let __v_25: G = G::from_u64(67);
-    let __v_26: G = G::from_u64(116);
-    let __v_27: G = G::from_u64(209);
-    let __v_28: G = G::from_u64(158);
-    let __v_29: G = G::from_u64(185);
-    let __v_30: G = G::from_u64(12);
-    let __v_31: G = G::from_u64(210);
+    let __v_0: G = G::from_u64(230);
+    let __v_1: G = G::from_u64(255);
+    let __v_2: G = G::from_u64(231);
+    let __v_3: G = G::from_u64(135);
+    let __v_4: G = G::from_u64(19);
+    let __v_5: G = G::from_u64(212);
+    let __v_6: G = G::from_u64(185);
+    let __v_7: G = G::from_u64(116);
+    let __v_8: G = G::from_u64(168);
+    let __v_9: G = G::from_u64(45);
+    let __v_10: G = G::from_u64(1);
+    let __v_11: G = G::from_u64(135);
+    let __v_12: G = G::from_u64(83);
+    let __v_13: G = G::from_u64(143);
+    let __v_14: G = G::from_u64(26);
+    let __v_15: G = G::from_u64(12);
+    let __v_16: G = G::from_u64(245);
+    let __v_17: G = G::from_u64(196);
+    let __v_18: G = G::from_u64(178);
+    let __v_19: G = G::from_u64(96);
+    let __v_20: G = G::from_u64(240);
+    let __v_21: G = G::from_u64(253);
+    let __v_22: G = G::from_u64(153);
+    let __v_23: G = G::from_u64(38);
+    let __v_24: G = G::from_u64(79);
+    let __v_25: G = G::from_u64(171);
+    let __v_26: G = G::from_u64(38);
+    let __v_27: G = G::from_u64(59);
+    let __v_28: G = G::from_u64(26);
+    let __v_29: G = G::from_u64(248);
+    let __v_30: G = G::from_u64(71);
+    let __v_31: G = G::from_u64(249);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_172] = [__v_32];
     record.function_queries[172].finish(&inp[..], &__ret[..], !unconstrained);
@@ -18035,38 +17978,38 @@ fn aiur_fn_173(
   unconstrained: bool,
 ) -> Result<[G; OUT_173], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(27);
-    let __v_1: G = G::from_u64(89);
-    let __v_2: G = G::from_u64(17);
-    let __v_3: G = G::from_u64(73);
-    let __v_4: G = G::from_u64(21);
-    let __v_5: G = G::from_u64(141);
-    let __v_6: G = G::from_u64(137);
-    let __v_7: G = G::from_u64(105);
-    let __v_8: G = G::from_u64(55);
-    let __v_9: G = G::from_u64(238);
-    let __v_10: G = G::from_u64(191);
-    let __v_11: G = G::from_u64(213);
-    let __v_12: G = G::from_u64(50);
-    let __v_13: G = G::from_u64(50);
-    let __v_14: G = G::from_u64(181);
-    let __v_15: G = G::from_u64(174);
-    let __v_16: G = G::from_u64(138);
-    let __v_17: G = G::from_u64(75);
-    let __v_18: G = G::from_u64(205);
-    let __v_19: G = G::from_u64(178);
-    let __v_20: G = G::from_u64(90);
-    let __v_21: G = G::from_u64(104);
-    let __v_22: G = G::from_u64(17);
-    let __v_23: G = G::from_u64(201);
-    let __v_24: G = G::from_u64(107);
-    let __v_25: G = G::from_u64(217);
-    let __v_26: G = G::from_u64(65);
-    let __v_27: G = G::from_u64(20);
-    let __v_28: G = G::from_u64(169);
-    let __v_29: G = G::from_u64(248);
-    let __v_30: G = G::from_u64(190);
-    let __v_31: G = G::from_u64(213);
+    let __v_0: G = G::from_u64(192);
+    let __v_1: G = G::from_u64(117);
+    let __v_2: G = G::from_u64(237);
+    let __v_3: G = G::from_u64(151);
+    let __v_4: G = G::from_u64(111);
+    let __v_5: G = G::from_u64(23);
+    let __v_6: G = G::from_u64(2);
+    let __v_7: G = G::from_u64(243);
+    let __v_8: G = G::from_u64(100);
+    let __v_9: G = G::from_u64(251);
+    let __v_10: G = G::from_u64(11);
+    let __v_11: G = G::from_u64(179);
+    let __v_12: G = G::from_u64(74);
+    let __v_13: G = G::from_u64(168);
+    let __v_14: G = G::from_u64(187);
+    let __v_15: G = G::from_u64(193);
+    let __v_16: G = G::from_u64(102);
+    let __v_17: G = G::from_u64(173);
+    let __v_18: G = G::from_u64(172);
+    let __v_19: G = G::from_u64(229);
+    let __v_20: G = G::from_u64(115);
+    let __v_21: G = G::from_u64(242);
+    let __v_22: G = G::from_u64(206);
+    let __v_23: G = G::from_u64(145);
+    let __v_24: G = G::from_u64(75);
+    let __v_25: G = G::from_u64(67);
+    let __v_26: G = G::from_u64(220);
+    let __v_27: G = G::from_u64(79);
+    let __v_28: G = G::from_u64(74);
+    let __v_29: G = G::from_u64(171);
+    let __v_30: G = G::from_u64(98);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_173] = [__v_32];
     record.function_queries[173].finish(&inp[..], &__ret[..], !unconstrained);
@@ -18084,38 +18027,38 @@ fn aiur_fn_174(
   unconstrained: bool,
 ) -> Result<[G; OUT_174], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(114);
-    let __v_1: G = G::from_u64(198);
-    let __v_2: G = G::from_u64(212);
-    let __v_3: G = G::from_u64(163);
-    let __v_4: G = G::from_u64(182);
-    let __v_5: G = G::from_u64(83);
-    let __v_6: G = G::from_u64(121);
-    let __v_7: G = G::from_u64(136);
-    let __v_8: G = G::from_u64(80);
-    let __v_9: G = G::from_u64(169);
-    let __v_10: G = G::from_u64(237);
-    let __v_11: G = G::from_u64(87);
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = G::from_u64(139);
-    let __v_14: G = G::from_u64(135);
-    let __v_15: G = G::from_u64(206);
-    let __v_16: G = G::from_u64(238);
-    let __v_17: G = G::from_u64(14);
-    let __v_18: G = G::from_u64(52);
-    let __v_19: G = G::from_u64(25);
-    let __v_20: G = G::from_u64(92);
-    let __v_21: G = G::from_u64(9);
-    let __v_22: G = G::from_u64(2);
-    let __v_23: G = G::from_u64(133);
-    let __v_24: G = G::from_u64(143);
-    let __v_25: G = G::from_u64(212);
-    let __v_26: G = G::from_u64(31);
-    let __v_27: G = G::from_u64(111);
-    let __v_28: G = G::from_u64(14);
-    let __v_29: G = G::from_u64(153);
-    let __v_30: G = G::from_u64(98);
-    let __v_31: G = G::from_u64(174);
+    let __v_0: G = G::from_u64(198);
+    let __v_1: G = G::from_u64(31);
+    let __v_2: G = G::from_u64(173);
+    let __v_3: G = G::from_u64(70);
+    let __v_4: G = G::from_u64(161);
+    let __v_5: G = G::from_u64(2);
+    let __v_6: G = G::from_u64(219);
+    let __v_7: G = G::from_u64(255);
+    let __v_8: G = G::from_u64(89);
+    let __v_9: G = G::from_u64(34);
+    let __v_10: G = G::from_u64(49);
+    let __v_11: G = G::from_u64(45);
+    let __v_12: G = G::from_u64(79);
+    let __v_13: G = G::from_u64(190);
+    let __v_14: G = G::from_u64(110);
+    let __v_15: G = G::from_u64(112);
+    let __v_16: G = G::from_u64(78);
+    let __v_17: G = G::from_u64(195);
+    let __v_18: G = G::from_u64(198);
+    let __v_19: G = G::from_u64(44);
+    let __v_20: G = G::from_u64(108);
+    let __v_21: G = G::from_u64(111);
+    let __v_22: G = G::from_u64(100);
+    let __v_23: G = G::from_u64(179);
+    let __v_24: G = G::from_u64(212);
+    let __v_25: G = G::from_u64(129);
+    let __v_26: G = G::from_u64(183);
+    let __v_27: G = G::from_u64(140);
+    let __v_28: G = G::from_u64(119);
+    let __v_29: G = G::from_u64(207);
+    let __v_30: G = G::from_u64(49);
+    let __v_31: G = G::from_u64(93);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_174] = [__v_32];
     record.function_queries[174].finish(&inp[..], &__ret[..], !unconstrained);
@@ -18133,38 +18076,38 @@ fn aiur_fn_175(
   unconstrained: bool,
 ) -> Result<[G; OUT_175], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(195);
-    let __v_1: G = G::from_u64(127);
-    let __v_2: G = G::from_u64(46);
-    let __v_3: G = G::from_u64(129);
-    let __v_4: G = G::from_u64(31);
-    let __v_5: G = G::from_u64(68);
-    let __v_6: G = G::from_u64(213);
-    let __v_7: G = G::from_u64(156);
-    let __v_8: G = G::from_u64(7);
-    let __v_9: G = G::from_u64(9);
-    let __v_10: G = G::from_u64(73);
-    let __v_11: G = G::from_u64(71);
-    let __v_12: G = G::from_u64(20);
-    let __v_13: G = G::from_u64(111);
-    let __v_14: G = G::from_u64(252);
-    let __v_15: G = G::from_u64(189);
-    let __v_16: G = G::from_u64(58);
-    let __v_17: G = G::from_u64(236);
-    let __v_18: G = G::from_u64(94);
-    let __v_19: G = G::from_u64(199);
-    let __v_20: G = G::from_u64(0);
-    let __v_21: G = G::from_u64(42);
-    let __v_22: G = G::from_u64(195);
-    let __v_23: G = G::from_u64(196);
-    let __v_24: G = G::from_u64(142);
-    let __v_25: G = G::from_u64(189);
-    let __v_26: G = G::from_u64(235);
-    let __v_27: G = G::from_u64(205);
-    let __v_28: G = G::from_u64(131);
-    let __v_29: G = G::from_u64(212);
-    let __v_30: G = G::from_u64(104);
-    let __v_31: G = G::from_u64(142);
+    let __v_0: G = G::from_u64(203);
+    let __v_1: G = G::from_u64(125);
+    let __v_2: G = G::from_u64(204);
+    let __v_3: G = G::from_u64(192);
+    let __v_4: G = G::from_u64(32);
+    let __v_5: G = G::from_u64(165);
+    let __v_6: G = G::from_u64(48);
+    let __v_7: G = G::from_u64(254);
+    let __v_8: G = G::from_u64(215);
+    let __v_9: G = G::from_u64(198);
+    let __v_10: G = G::from_u64(34);
+    let __v_11: G = G::from_u64(177);
+    let __v_12: G = G::from_u64(0);
+    let __v_13: G = G::from_u64(238);
+    let __v_14: G = G::from_u64(82);
+    let __v_15: G = G::from_u64(193);
+    let __v_16: G = G::from_u64(7);
+    let __v_17: G = G::from_u64(139);
+    let __v_18: G = G::from_u64(80);
+    let __v_19: G = G::from_u64(24);
+    let __v_20: G = G::from_u64(21);
+    let __v_21: G = G::from_u64(155);
+    let __v_22: G = G::from_u64(164);
+    let __v_23: G = G::from_u64(104);
+    let __v_24: G = G::from_u64(47);
+    let __v_25: G = G::from_u64(129);
+    let __v_26: G = G::from_u64(126);
+    let __v_27: G = G::from_u64(55);
+    let __v_28: G = G::from_u64(118);
+    let __v_29: G = G::from_u64(120);
+    let __v_30: G = G::from_u64(158);
+    let __v_31: G = G::from_u64(232);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_175] = [__v_32];
     record.function_queries[175].finish(&inp[..], &__ret[..], !unconstrained);
@@ -18181,6 +18124,251 @@ fn aiur_fn_176(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_176], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(216);
+    let __v_1: G = G::from_u64(166);
+    let __v_2: G = G::from_u64(176);
+    let __v_3: G = G::from_u64(90);
+    let __v_4: G = G::from_u64(26);
+    let __v_5: G = G::from_u64(78);
+    let __v_6: G = G::from_u64(92);
+    let __v_7: G = G::from_u64(173);
+    let __v_8: G = G::from_u64(198);
+    let __v_9: G = G::from_u64(156);
+    let __v_10: G = G::from_u64(83);
+    let __v_11: G = G::from_u64(121);
+    let __v_12: G = G::from_u64(46);
+    let __v_13: G = G::from_u64(142);
+    let __v_14: G = G::from_u64(19);
+    let __v_15: G = G::from_u64(3);
+    let __v_16: G = G::from_u64(20);
+    let __v_17: G = G::from_u64(116);
+    let __v_18: G = G::from_u64(94);
+    let __v_19: G = G::from_u64(118);
+    let __v_20: G = G::from_u64(227);
+    let __v_21: G = G::from_u64(43);
+    let __v_22: G = G::from_u64(179);
+    let __v_23: G = G::from_u64(10);
+    let __v_24: G = G::from_u64(156);
+    let __v_25: G = G::from_u64(224);
+    let __v_26: G = G::from_u64(39);
+    let __v_27: G = G::from_u64(47);
+    let __v_28: G = G::from_u64(160);
+    let __v_29: G = G::from_u64(121);
+    let __v_30: G = G::from_u64(232);
+    let __v_31: G = G::from_u64(166);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_176] = [__v_32];
+    record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_177: usize = 0;
+const IN_177: usize = 0;
+const OUT_177: usize = 1;
+fn aiur_fn_177(
+  inp: [G; IN_177],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_177], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(92);
+    let __v_1: G = G::from_u64(21);
+    let __v_2: G = G::from_u64(249);
+    let __v_3: G = G::from_u64(142);
+    let __v_4: G = G::from_u64(43);
+    let __v_5: G = G::from_u64(217);
+    let __v_6: G = G::from_u64(194);
+    let __v_7: G = G::from_u64(87);
+    let __v_8: G = G::from_u64(188);
+    let __v_9: G = G::from_u64(223);
+    let __v_10: G = G::from_u64(172);
+    let __v_11: G = G::from_u64(98);
+    let __v_12: G = G::from_u64(176);
+    let __v_13: G = G::from_u64(4);
+    let __v_14: G = G::from_u64(58);
+    let __v_15: G = G::from_u64(46);
+    let __v_16: G = G::from_u64(62);
+    let __v_17: G = G::from_u64(43);
+    let __v_18: G = G::from_u64(189);
+    let __v_19: G = G::from_u64(255);
+    let __v_20: G = G::from_u64(139);
+    let __v_21: G = G::from_u64(33);
+    let __v_22: G = G::from_u64(15);
+    let __v_23: G = G::from_u64(16);
+    let __v_24: G = G::from_u64(75);
+    let __v_25: G = G::from_u64(92);
+    let __v_26: G = G::from_u64(55);
+    let __v_27: G = G::from_u64(57);
+    let __v_28: G = G::from_u64(232);
+    let __v_29: G = G::from_u64(98);
+    let __v_30: G = G::from_u64(172);
+    let __v_31: G = G::from_u64(12);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_177] = [__v_32];
+    record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_178: usize = 0;
+const IN_178: usize = 0;
+const OUT_178: usize = 1;
+fn aiur_fn_178(
+  inp: [G; IN_178],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_178], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(63);
+    let __v_1: G = G::from_u64(146);
+    let __v_2: G = G::from_u64(114);
+    let __v_3: G = G::from_u64(83);
+    let __v_4: G = G::from_u64(36);
+    let __v_5: G = G::from_u64(176);
+    let __v_6: G = G::from_u64(159);
+    let __v_7: G = G::from_u64(167);
+    let __v_8: G = G::from_u64(92);
+    let __v_9: G = G::from_u64(111);
+    let __v_10: G = G::from_u64(205);
+    let __v_11: G = G::from_u64(22);
+    let __v_12: G = G::from_u64(218);
+    let __v_13: G = G::from_u64(134);
+    let __v_14: G = G::from_u64(54);
+    let __v_15: G = G::from_u64(113);
+    let __v_16: G = G::from_u64(66);
+    let __v_17: G = G::from_u64(143);
+    let __v_18: G = G::from_u64(243);
+    let __v_19: G = G::from_u64(59);
+    let __v_20: G = G::from_u64(125);
+    let __v_21: G = G::from_u64(182);
+    let __v_22: G = G::from_u64(103);
+    let __v_23: G = G::from_u64(235);
+    let __v_24: G = G::from_u64(118);
+    let __v_25: G = G::from_u64(14);
+    let __v_26: G = G::from_u64(28);
+    let __v_27: G = G::from_u64(213);
+    let __v_28: G = G::from_u64(3);
+    let __v_29: G = G::from_u64(162);
+    let __v_30: G = G::from_u64(188);
+    let __v_31: G = G::from_u64(173);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_178] = [__v_32];
+    record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_179: usize = 0;
+const IN_179: usize = 0;
+const OUT_179: usize = 1;
+fn aiur_fn_179(
+  inp: [G; IN_179],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_179], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(255);
+    let __v_1: G = G::from_u64(211);
+    let __v_2: G = G::from_u64(240);
+    let __v_3: G = G::from_u64(42);
+    let __v_4: G = G::from_u64(25);
+    let __v_5: G = G::from_u64(253);
+    let __v_6: G = G::from_u64(166);
+    let __v_7: G = G::from_u64(73);
+    let __v_8: G = G::from_u64(170);
+    let __v_9: G = G::from_u64(86);
+    let __v_10: G = G::from_u64(8);
+    let __v_11: G = G::from_u64(237);
+    let __v_12: G = G::from_u64(129);
+    let __v_13: G = G::from_u64(141);
+    let __v_14: G = G::from_u64(179);
+    let __v_15: G = G::from_u64(130);
+    let __v_16: G = G::from_u64(225);
+    let __v_17: G = G::from_u64(96);
+    let __v_18: G = G::from_u64(35);
+    let __v_19: G = G::from_u64(27);
+    let __v_20: G = G::from_u64(118);
+    let __v_21: G = G::from_u64(213);
+    let __v_22: G = G::from_u64(176);
+    let __v_23: G = G::from_u64(145);
+    let __v_24: G = G::from_u64(118);
+    let __v_25: G = G::from_u64(215);
+    let __v_26: G = G::from_u64(221);
+    let __v_27: G = G::from_u64(26);
+    let __v_28: G = G::from_u64(141);
+    let __v_29: G = G::from_u64(91);
+    let __v_30: G = G::from_u64(30);
+    let __v_31: G = G::from_u64(197);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_179] = [__v_32];
+    record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_180: usize = 0;
+const IN_180: usize = 0;
+const OUT_180: usize = 1;
+fn aiur_fn_180(
+  inp: [G; IN_180],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_180], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(104);
+    let __v_1: G = G::from_u64(163);
+    let __v_2: G = G::from_u64(100);
+    let __v_3: G = G::from_u64(62);
+    let __v_4: G = G::from_u64(198);
+    let __v_5: G = G::from_u64(152);
+    let __v_6: G = G::from_u64(22);
+    let __v_7: G = G::from_u64(174);
+    let __v_8: G = G::from_u64(193);
+    let __v_9: G = G::from_u64(7);
+    let __v_10: G = G::from_u64(48);
+    let __v_11: G = G::from_u64(45);
+    let __v_12: G = G::from_u64(219);
+    let __v_13: G = G::from_u64(250);
+    let __v_14: G = G::from_u64(5);
+    let __v_15: G = G::from_u64(76);
+    let __v_16: G = G::from_u64(235);
+    let __v_17: G = G::from_u64(205);
+    let __v_18: G = G::from_u64(62);
+    let __v_19: G = G::from_u64(193);
+    let __v_20: G = G::from_u64(115);
+    let __v_21: G = G::from_u64(205);
+    let __v_22: G = G::from_u64(95);
+    let __v_23: G = G::from_u64(126);
+    let __v_24: G = G::from_u64(109);
+    let __v_25: G = G::from_u64(136);
+    let __v_26: G = G::from_u64(54);
+    let __v_27: G = G::from_u64(56);
+    let __v_28: G = G::from_u64(99);
+    let __v_29: G = G::from_u64(26);
+    let __v_30: G = G::from_u64(254);
+    let __v_31: G = G::from_u64(101);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_180] = [__v_32];
+    record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_181: usize = 0;
+const IN_181: usize = 0;
+const OUT_181: usize = 1;
+fn aiur_fn_181(
+  inp: [G; IN_181],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_181], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(162);
     let __v_1: G = G::from_u64(154);
@@ -18215,21 +18403,21 @@ fn aiur_fn_176(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_176] = [__v_32];
-    record.function_queries[176].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_181] = [__v_32];
+    record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_177: usize = 0;
-const IN_177: usize = 0;
-const OUT_177: usize = 1;
-fn aiur_fn_177(
-  inp: [G; IN_177],
+const INPUT_SIZE_182: usize = 0;
+const IN_182: usize = 0;
+const OUT_182: usize = 1;
+fn aiur_fn_182(
+  inp: [G; IN_182],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_177], ExecError> {
+) -> Result<[G; OUT_182], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(221);
     let __v_1: G = G::from_u64(161);
@@ -18264,380 +18452,380 @@ fn aiur_fn_177(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_177] = [__v_32];
-    record.function_queries[177].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_182] = [__v_32];
+    record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_178: usize = 0;
-const IN_178: usize = 0;
-const OUT_178: usize = 1;
-fn aiur_fn_178(
-  inp: [G; IN_178],
+const INPUT_SIZE_183: usize = 0;
+const IN_183: usize = 0;
+const OUT_183: usize = 1;
+fn aiur_fn_183(
+  inp: [G; IN_183],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_178], ExecError> {
+) -> Result<[G; OUT_183], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(80);
-    let __v_1: G = G::from_u64(96);
-    let __v_2: G = G::from_u64(162);
-    let __v_3: G = G::from_u64(45);
-    let __v_4: G = G::from_u64(248);
-    let __v_5: G = G::from_u64(99);
-    let __v_6: G = G::from_u64(7);
-    let __v_7: G = G::from_u64(221);
-    let __v_8: G = G::from_u64(139);
-    let __v_9: G = G::from_u64(190);
-    let __v_10: G = G::from_u64(101);
-    let __v_11: G = G::from_u64(110);
-    let __v_12: G = G::from_u64(19);
-    let __v_13: G = G::from_u64(134);
-    let __v_14: G = G::from_u64(143);
-    let __v_15: G = G::from_u64(58);
-    let __v_16: G = G::from_u64(22);
-    let __v_17: G = G::from_u64(24);
-    let __v_18: G = G::from_u64(231);
-    let __v_19: G = G::from_u64(160);
-    let __v_20: G = G::from_u64(216);
-    let __v_21: G = G::from_u64(128);
-    let __v_22: G = G::from_u64(184);
-    let __v_23: G = G::from_u64(203);
-    let __v_24: G = G::from_u64(176);
-    let __v_25: G = G::from_u64(7);
-    let __v_26: G = G::from_u64(89);
-    let __v_27: G = G::from_u64(207);
-    let __v_28: G = G::from_u64(253);
-    let __v_29: G = G::from_u64(49);
-    let __v_30: G = G::from_u64(128);
-    let __v_31: G = G::from_u64(13);
+    let __v_0: G = G::from_u64(111);
+    let __v_1: G = G::from_u64(98);
+    let __v_2: G = G::from_u64(6);
+    let __v_3: G = G::from_u64(84);
+    let __v_4: G = G::from_u64(211);
+    let __v_5: G = G::from_u64(65);
+    let __v_6: G = G::from_u64(153);
+    let __v_7: G = G::from_u64(10);
+    let __v_8: G = G::from_u64(48);
+    let __v_9: G = G::from_u64(19);
+    let __v_10: G = G::from_u64(135);
+    let __v_11: G = G::from_u64(184);
+    let __v_12: G = G::from_u64(14);
+    let __v_13: G = G::from_u64(247);
+    let __v_14: G = G::from_u64(91);
+    let __v_15: G = G::from_u64(30);
+    let __v_16: G = G::from_u64(11);
+    let __v_17: G = G::from_u64(97);
+    let __v_18: G = G::from_u64(48);
+    let __v_19: G = G::from_u64(221);
+    let __v_20: G = G::from_u64(241);
+    let __v_21: G = G::from_u64(145);
+    let __v_22: G = G::from_u64(100);
+    let __v_23: G = G::from_u64(2);
+    let __v_24: G = G::from_u64(91);
+    let __v_25: G = G::from_u64(109);
+    let __v_26: G = G::from_u64(195);
+    let __v_27: G = G::from_u64(123);
+    let __v_28: G = G::from_u64(243);
+    let __v_29: G = G::from_u64(195);
+    let __v_30: G = G::from_u64(220);
+    let __v_31: G = G::from_u64(24);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_178] = [__v_32];
-    record.function_queries[178].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_183] = [__v_32];
+    record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_179: usize = 0;
-const IN_179: usize = 0;
-const OUT_179: usize = 1;
-fn aiur_fn_179(
-  inp: [G; IN_179],
+const INPUT_SIZE_184: usize = 0;
+const IN_184: usize = 0;
+const OUT_184: usize = 1;
+fn aiur_fn_184(
+  inp: [G; IN_184],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_179], ExecError> {
+) -> Result<[G; OUT_184], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(132);
-    let __v_1: G = G::from_u64(254);
-    let __v_2: G = G::from_u64(61);
-    let __v_3: G = G::from_u64(15);
-    let __v_4: G = G::from_u64(8);
-    let __v_5: G = G::from_u64(240);
-    let __v_6: G = G::from_u64(101);
-    let __v_7: G = G::from_u64(26);
-    let __v_8: G = G::from_u64(111);
-    let __v_9: G = G::from_u64(9);
-    let __v_10: G = G::from_u64(54);
-    let __v_11: G = G::from_u64(169);
-    let __v_12: G = G::from_u64(160);
-    let __v_13: G = G::from_u64(241);
-    let __v_14: G = G::from_u64(142);
-    let __v_15: G = G::from_u64(79);
-    let __v_16: G = G::from_u64(13);
-    let __v_17: G = G::from_u64(172);
-    let __v_18: G = G::from_u64(225);
-    let __v_19: G = G::from_u64(105);
-    let __v_20: G = G::from_u64(172);
-    let __v_21: G = G::from_u64(66);
-    let __v_22: G = G::from_u64(51);
-    let __v_23: G = G::from_u64(191);
-    let __v_24: G = G::from_u64(26);
-    let __v_25: G = G::from_u64(218);
-    let __v_26: G = G::from_u64(208);
-    let __v_27: G = G::from_u64(93);
-    let __v_28: G = G::from_u64(110);
-    let __v_29: G = G::from_u64(7);
-    let __v_30: G = G::from_u64(138);
-    let __v_31: G = G::from_u64(37);
+    let __v_0: G = G::from_u64(232);
+    let __v_1: G = G::from_u64(91);
+    let __v_2: G = G::from_u64(245);
+    let __v_3: G = G::from_u64(22);
+    let __v_4: G = G::from_u64(199);
+    let __v_5: G = G::from_u64(108);
+    let __v_6: G = G::from_u64(173);
+    let __v_7: G = G::from_u64(216);
+    let __v_8: G = G::from_u64(206);
+    let __v_9: G = G::from_u64(31);
+    let __v_10: G = G::from_u64(218);
+    let __v_11: G = G::from_u64(179);
+    let __v_12: G = G::from_u64(204);
+    let __v_13: G = G::from_u64(148);
+    let __v_14: G = G::from_u64(237);
+    let __v_15: G = G::from_u64(104);
+    let __v_16: G = G::from_u64(94);
+    let __v_17: G = G::from_u64(71);
+    let __v_18: G = G::from_u64(190);
+    let __v_19: G = G::from_u64(60);
+    let __v_20: G = G::from_u64(122);
+    let __v_21: G = G::from_u64(139);
+    let __v_22: G = G::from_u64(82);
+    let __v_23: G = G::from_u64(245);
+    let __v_24: G = G::from_u64(63);
+    let __v_25: G = G::from_u64(226);
+    let __v_26: G = G::from_u64(179);
+    let __v_27: G = G::from_u64(80);
+    let __v_28: G = G::from_u64(46);
+    let __v_29: G = G::from_u64(111);
+    let __v_30: G = G::from_u64(112);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_179] = [__v_32];
-    record.function_queries[179].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_184] = [__v_32];
+    record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_180: usize = 0;
-const IN_180: usize = 0;
-const OUT_180: usize = 1;
-fn aiur_fn_180(
-  inp: [G; IN_180],
+const INPUT_SIZE_185: usize = 0;
+const IN_185: usize = 0;
+const OUT_185: usize = 1;
+fn aiur_fn_185(
+  inp: [G; IN_185],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_180], ExecError> {
+) -> Result<[G; OUT_185], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(212);
-    let __v_1: G = G::from_u64(215);
-    let __v_2: G = G::from_u64(117);
-    let __v_3: G = G::from_u64(206);
-    let __v_4: G = G::from_u64(255);
-    let __v_5: G = G::from_u64(55);
-    let __v_6: G = G::from_u64(171);
-    let __v_7: G = G::from_u64(122);
-    let __v_8: G = G::from_u64(64);
-    let __v_9: G = G::from_u64(36);
-    let __v_10: G = G::from_u64(22);
-    let __v_11: G = G::from_u64(17);
-    let __v_12: G = G::from_u64(143);
-    let __v_13: G = G::from_u64(29);
-    let __v_14: G = G::from_u64(44);
-    let __v_15: G = G::from_u64(229);
-    let __v_16: G = G::from_u64(185);
-    let __v_17: G = G::from_u64(231);
-    let __v_18: G = G::from_u64(242);
-    let __v_19: G = G::from_u64(20);
-    let __v_20: G = G::from_u64(61);
-    let __v_21: G = G::from_u64(12);
-    let __v_22: G = G::from_u64(61);
-    let __v_23: G = G::from_u64(200);
-    let __v_24: G = G::from_u64(254);
-    let __v_25: G = G::from_u64(84);
-    let __v_26: G = G::from_u64(49);
-    let __v_27: G = G::from_u64(87);
-    let __v_28: G = G::from_u64(29);
-    let __v_29: G = G::from_u64(243);
-    let __v_30: G = G::from_u64(38);
-    let __v_31: G = G::from_u64(12);
+    let __v_0: G = G::from_u64(186);
+    let __v_1: G = G::from_u64(204);
+    let __v_2: G = G::from_u64(76);
+    let __v_3: G = G::from_u64(129);
+    let __v_4: G = G::from_u64(74);
+    let __v_5: G = G::from_u64(69);
+    let __v_6: G = G::from_u64(114);
+    let __v_7: G = G::from_u64(221);
+    let __v_8: G = G::from_u64(253);
+    let __v_9: G = G::from_u64(150);
+    let __v_10: G = G::from_u64(154);
+    let __v_11: G = G::from_u64(24);
+    let __v_12: G = G::from_u64(87);
+    let __v_13: G = G::from_u64(173);
+    let __v_14: G = G::from_u64(254);
+    let __v_15: G = G::from_u64(24);
+    let __v_16: G = G::from_u64(35);
+    let __v_17: G = G::from_u64(158);
+    let __v_18: G = G::from_u64(182);
+    let __v_19: G = G::from_u64(189);
+    let __v_20: G = G::from_u64(139);
+    let __v_21: G = G::from_u64(22);
+    let __v_22: G = G::from_u64(39);
+    let __v_23: G = G::from_u64(238);
+    let __v_24: G = G::from_u64(121);
+    let __v_25: G = G::from_u64(116);
+    let __v_26: G = G::from_u64(74);
+    let __v_27: G = G::from_u64(106);
+    let __v_28: G = G::from_u64(155);
+    let __v_29: G = G::from_u64(35);
+    let __v_30: G = G::from_u64(176);
+    let __v_31: G = G::from_u64(48);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_180] = [__v_32];
-    record.function_queries[180].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_185] = [__v_32];
+    record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_181: usize = 0;
-const IN_181: usize = 0;
-const OUT_181: usize = 1;
-fn aiur_fn_181(
-  inp: [G; IN_181],
+const INPUT_SIZE_186: usize = 0;
+const IN_186: usize = 0;
+const OUT_186: usize = 1;
+fn aiur_fn_186(
+  inp: [G; IN_186],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_181], ExecError> {
+) -> Result<[G; OUT_186], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(32);
-    let __v_1: G = G::from_u64(117);
-    let __v_2: G = G::from_u64(189);
-    let __v_3: G = G::from_u64(165);
-    let __v_4: G = G::from_u64(69);
-    let __v_5: G = G::from_u64(123);
-    let __v_6: G = G::from_u64(41);
-    let __v_7: G = G::from_u64(155);
-    let __v_8: G = G::from_u64(39);
-    let __v_9: G = G::from_u64(36);
-    let __v_10: G = G::from_u64(103);
-    let __v_11: G = G::from_u64(112);
-    let __v_12: G = G::from_u64(200);
-    let __v_13: G = G::from_u64(65);
-    let __v_14: G = G::from_u64(98);
-    let __v_15: G = G::from_u64(115);
-    let __v_16: G = G::from_u64(104);
-    let __v_17: G = G::from_u64(107);
-    let __v_18: G = G::from_u64(191);
-    let __v_19: G = G::from_u64(98);
-    let __v_20: G = G::from_u64(122);
-    let __v_21: G = G::from_u64(166);
-    let __v_22: G = G::from_u64(160);
-    let __v_23: G = G::from_u64(26);
-    let __v_24: G = G::from_u64(196);
-    let __v_25: G = G::from_u64(19);
-    let __v_26: G = G::from_u64(162);
-    let __v_27: G = G::from_u64(126);
-    let __v_28: G = G::from_u64(88);
-    let __v_29: G = G::from_u64(62);
-    let __v_30: G = G::from_u64(185);
-    let __v_31: G = G::from_u64(93);
+    let __v_0: G = G::from_u64(182);
+    let __v_1: G = G::from_u64(50);
+    let __v_2: G = G::from_u64(125);
+    let __v_3: G = G::from_u64(154);
+    let __v_4: G = G::from_u64(27);
+    let __v_5: G = G::from_u64(187);
+    let __v_6: G = G::from_u64(70);
+    let __v_7: G = G::from_u64(26);
+    let __v_8: G = G::from_u64(68);
+    let __v_9: G = G::from_u64(127);
+    let __v_10: G = G::from_u64(12);
+    let __v_11: G = G::from_u64(151);
+    let __v_12: G = G::from_u64(30);
+    let __v_13: G = G::from_u64(98);
+    let __v_14: G = G::from_u64(45);
+    let __v_15: G = G::from_u64(217);
+    let __v_16: G = G::from_u64(163);
+    let __v_17: G = G::from_u64(81);
+    let __v_18: G = G::from_u64(50);
+    let __v_19: G = G::from_u64(189);
+    let __v_20: G = G::from_u64(125);
+    let __v_21: G = G::from_u64(231);
+    let __v_22: G = G::from_u64(91);
+    let __v_23: G = G::from_u64(246);
+    let __v_24: G = G::from_u64(158);
+    let __v_25: G = G::from_u64(32);
+    let __v_26: G = G::from_u64(121);
+    let __v_27: G = G::from_u64(77);
+    let __v_28: G = G::from_u64(122);
+    let __v_29: G = G::from_u64(14);
+    let __v_30: G = G::from_u64(133);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_181] = [__v_32];
-    record.function_queries[181].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_186] = [__v_32];
+    record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_182: usize = 0;
-const IN_182: usize = 0;
-const OUT_182: usize = 1;
-fn aiur_fn_182(
-  inp: [G; IN_182],
+const INPUT_SIZE_187: usize = 0;
+const IN_187: usize = 0;
+const OUT_187: usize = 1;
+fn aiur_fn_187(
+  inp: [G; IN_187],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_182], ExecError> {
+) -> Result<[G; OUT_187], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(126);
-    let __v_1: G = G::from_u64(78);
-    let __v_2: G = G::from_u64(155);
-    let __v_3: G = G::from_u64(51);
-    let __v_4: G = G::from_u64(182);
-    let __v_5: G = G::from_u64(150);
-    let __v_6: G = G::from_u64(167);
-    let __v_7: G = G::from_u64(211);
-    let __v_8: G = G::from_u64(252);
-    let __v_9: G = G::from_u64(225);
-    let __v_10: G = G::from_u64(116);
-    let __v_11: G = G::from_u64(93);
-    let __v_12: G = G::from_u64(251);
-    let __v_13: G = G::from_u64(95);
-    let __v_14: G = G::from_u64(190);
-    let __v_15: G = G::from_u64(235);
-    let __v_16: G = G::from_u64(147);
-    let __v_17: G = G::from_u64(143);
-    let __v_18: G = G::from_u64(200);
-    let __v_19: G = G::from_u64(136);
-    let __v_20: G = G::from_u64(42);
-    let __v_21: G = G::from_u64(130);
-    let __v_22: G = G::from_u64(190);
-    let __v_23: G = G::from_u64(225);
-    let __v_24: G = G::from_u64(87);
-    let __v_25: G = G::from_u64(35);
-    let __v_26: G = G::from_u64(224);
-    let __v_27: G = G::from_u64(210);
-    let __v_28: G = G::from_u64(83);
-    let __v_29: G = G::from_u64(229);
-    let __v_30: G = G::from_u64(145);
-    let __v_31: G = G::from_u64(88);
+    let __v_0: G = G::from_u64(234);
+    let __v_1: G = G::from_u64(101);
+    let __v_2: G = G::from_u64(245);
+    let __v_3: G = G::from_u64(23);
+    let __v_4: G = G::from_u64(69);
+    let __v_5: G = G::from_u64(127);
+    let __v_6: G = G::from_u64(174);
+    let __v_7: G = G::from_u64(155);
+    let __v_8: G = G::from_u64(112);
+    let __v_9: G = G::from_u64(82);
+    let __v_10: G = G::from_u64(153);
+    let __v_11: G = G::from_u64(218);
+    let __v_12: G = G::from_u64(8);
+    let __v_13: G = G::from_u64(176);
+    let __v_14: G = G::from_u64(211);
+    let __v_15: G = G::from_u64(200);
+    let __v_16: G = G::from_u64(207);
+    let __v_17: G = G::from_u64(154);
+    let __v_18: G = G::from_u64(71);
+    let __v_19: G = G::from_u64(111);
+    let __v_20: G = G::from_u64(22);
+    let __v_21: G = G::from_u64(71);
+    let __v_22: G = G::from_u64(12);
+    let __v_23: G = G::from_u64(202);
+    let __v_24: G = G::from_u64(92);
+    let __v_25: G = G::from_u64(174);
+    let __v_26: G = G::from_u64(94);
+    let __v_27: G = G::from_u64(167);
+    let __v_28: G = G::from_u64(189);
+    let __v_29: G = G::from_u64(35);
+    let __v_30: G = G::from_u64(130);
+    let __v_31: G = G::from_u64(48);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_182] = [__v_32];
-    record.function_queries[182].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_187] = [__v_32];
+    record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_183: usize = 0;
-const IN_183: usize = 0;
-const OUT_183: usize = 1;
-fn aiur_fn_183(
-  inp: [G; IN_183],
+const INPUT_SIZE_188: usize = 0;
+const IN_188: usize = 0;
+const OUT_188: usize = 1;
+fn aiur_fn_188(
+  inp: [G; IN_188],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_183], ExecError> {
+) -> Result<[G; OUT_188], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(128);
-    let __v_1: G = G::from_u64(249);
-    let __v_2: G = G::from_u64(117);
-    let __v_3: G = G::from_u64(222);
-    let __v_4: G = G::from_u64(217);
-    let __v_5: G = G::from_u64(214);
-    let __v_6: G = G::from_u64(171);
-    let __v_7: G = G::from_u64(112);
-    let __v_8: G = G::from_u64(149);
-    let __v_9: G = G::from_u64(233);
-    let __v_10: G = G::from_u64(219);
-    let __v_11: G = G::from_u64(46);
-    let __v_12: G = G::from_u64(209);
-    let __v_13: G = G::from_u64(207);
-    let __v_14: G = G::from_u64(166);
-    let __v_15: G = G::from_u64(245);
-    let __v_16: G = G::from_u64(195);
-    let __v_17: G = G::from_u64(94);
-    let __v_18: G = G::from_u64(175);
-    let __v_19: G = G::from_u64(229);
-    let __v_20: G = G::from_u64(197);
-    let __v_21: G = G::from_u64(105);
-    let __v_22: G = G::from_u64(144);
-    let __v_23: G = G::from_u64(226);
-    let __v_24: G = G::from_u64(193);
-    let __v_25: G = G::from_u64(50);
-    let __v_26: G = G::from_u64(27);
-    let __v_27: G = G::from_u64(2);
-    let __v_28: G = G::from_u64(197);
-    let __v_29: G = G::from_u64(102);
-    let __v_30: G = G::from_u64(78);
-    let __v_31: G = G::from_u64(108);
+    let __v_0: G = G::from_u64(0);
+    let __v_1: G = G::from_u64(194);
+    let __v_2: G = G::from_u64(102);
+    let __v_3: G = G::from_u64(131);
+    let __v_4: G = G::from_u64(79);
+    let __v_5: G = G::from_u64(144);
+    let __v_6: G = G::from_u64(57);
+    let __v_7: G = G::from_u64(147);
+    let __v_8: G = G::from_u64(27);
+    let __v_9: G = G::from_u64(75);
+    let __v_10: G = G::from_u64(226);
+    let __v_11: G = G::from_u64(250);
+    let __v_12: G = G::from_u64(197);
+    let __v_13: G = G::from_u64(88);
+    let __v_14: G = G::from_u64(76);
+    let __v_15: G = G::from_u64(209);
+    let __v_16: G = G::from_u64(118);
+    let __v_17: G = G::from_u64(160);
+    let __v_18: G = G::from_u64(174);
+    let __v_19: G = G::from_u64(126);
+    let __v_20: G = G::from_u64(228);
+    let __v_21: G = G::from_u64(203);
+    let __v_22: G = G::from_u64(64);
+    let __v_23: G = G::from_u64(100);
+    let __v_24: G = G::from_u64(221);
+    let __v_25: G = G::from_u64(181);
+    let __v_26: G = G::from_u64(224);
+    let __v_27: G = G::from_u64(77);
+    let __v_28: G = G::from_u64(209);
+    let __v_29: G = G::from_u64(43);
+    let __v_30: G = G::from_u64(108);
+    let __v_31: G = G::from_u64(187);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_183] = [__v_32];
-    record.function_queries[183].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_188] = [__v_32];
+    record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_184: usize = 1;
-const IN_184: usize = 1;
-const OUT_184: usize = 1;
-fn aiur_fn_184(
-  inp: [G; IN_184],
+const INPUT_SIZE_189: usize = 1;
+const IN_189: usize = 1;
+const OUT_189: usize = 1;
+fn aiur_fn_189(
+  inp: [G; IN_189],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_184], ExecError> {
+) -> Result<[G; OUT_189], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_184] = [__v_3];
-        record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_189] = [__v_3];
+        record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_184] = [__v_5];
-            record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_189] = [__v_5];
+            record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_184] = [__v_7];
-                record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_189] = [__v_7];
+                record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_184] = [__v_9];
-                    record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_189] = [__v_9];
+                    record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_184] = [__v_11];
-                        record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_189] = [__v_11];
+                        record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_11: G = G::from_u64(0);
-                        let __ret: [G; OUT_184] = [__v_11];
-                        record.function_queries[184].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_189] = [__v_11];
+                        record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -18652,15 +18840,15 @@ fn aiur_fn_184(
   })
 }
 
-const INPUT_SIZE_185: usize = 0;
-const IN_185: usize = 0;
-const OUT_185: usize = 1;
-fn aiur_fn_185(
-  inp: [G; IN_185],
+const INPUT_SIZE_190: usize = 0;
+const IN_190: usize = 0;
+const OUT_190: usize = 1;
+fn aiur_fn_190(
+  inp: [G; IN_190],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_185], ExecError> {
+) -> Result<[G; OUT_190], 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);
@@ -18679,21 +18867,21 @@ fn aiur_fn_185(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_185] = [__v_16];
-    record.function_queries[185].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_190] = [__v_16];
+    record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_186: usize = 0;
-const IN_186: usize = 0;
-const OUT_186: usize = 1;
-fn aiur_fn_186(
-  inp: [G; IN_186],
+const INPUT_SIZE_191: usize = 0;
+const IN_191: usize = 0;
+const OUT_191: usize = 1;
+fn aiur_fn_191(
+  inp: [G; IN_191],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_186], ExecError> {
+) -> Result<[G; OUT_191], 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);
@@ -18712,72 +18900,72 @@ fn aiur_fn_186(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_186] = [__v_16];
-    record.function_queries[186].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_191] = [__v_16];
+    record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_187: usize = 3;
-const IN_187: usize = 3;
-const OUT_187: usize = 2;
-fn aiur_fn_187(
-  inp: [G; IN_187],
+const INPUT_SIZE_192: usize = 3;
+const IN_192: usize = 3;
+const OUT_192: usize = 2;
+fn aiur_fn_192(
+  inp: [G; IN_192],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_187], ExecError> {
+) -> Result<[G; OUT_192], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_187] = [__v_5, __v_6];
-        record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_192] = [__v_5, __v_6];
+        record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = []; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_187] = [__v_7, __v_8];
-            record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_192] = [__v_7, __v_8];
+            record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = []; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __v_10: G = __r_arr[1];
-                let __ret: [G; OUT_187] = [__v_9, __v_10];
-                record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_192] = [__v_9, __v_10];
+                record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = []; let __cu = unconstrained; let __hit = record.function_queries[186].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[186].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[186].bump_multiplicity(__i); } let __ret: [G; OUT_186] = unsafe { *(record.function_queries[186].output_at(__i).as_ptr() as *const [G; OUT_186]) }; __ret }, _ => aiur_fn_186(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
@@ -18789,12 +18977,12 @@ fn aiur_fn_187(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_187] = [__v_14, __v_18];
-                    record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_192] = [__v_14, __v_18];
+                    record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
                     let __v_15: G = G::from_u64(1);
                     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 };
@@ -18805,31 +18993,31 @@ fn aiur_fn_187(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_187] = [__v_17, __v_21];
-                        record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_192] = [__v_17, __v_21];
+                        record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_17: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                         let __v_18: G = __r_arr[0];
-                        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_18, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_18, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
                         let __v_19: G = __r_arr[0];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } };
                             let __v_20: G = __r_arr[0];
                             let __v_21: G = __r_arr[1];
-                            let __ret: [G; OUT_187] = [__v_20, __v_21];
-                            record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_192] = [__v_20, __v_21];
+                            record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } };
                             let __v_20: G = __r_arr[0];
                             let __v_21: G = __r_arr[1];
-                            let __ret: [G; OUT_187] = [__v_20, __v_21];
-                            record.function_queries[187].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_192] = [__v_20, __v_21];
+                            record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -18846,18 +19034,18 @@ fn aiur_fn_187(
   })
 }
 
-const INPUT_SIZE_188: usize = 1;
-const IN_188: usize = 1;
-const OUT_188: usize = 2;
-fn aiur_fn_188(
-  inp: [G; IN_188],
+const INPUT_SIZE_193: usize = 1;
+const IN_193: usize = 1;
+const OUT_193: usize = 2;
+fn aiur_fn_193(
+  inp: [G; IN_193],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_188], ExecError> {
+) -> Result<[G; OUT_193], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -18868,15 +19056,15 @@ fn aiur_fn_188(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_188] = [__v_4, __v_8];
-        record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_193] = [__v_4, __v_8];
+        record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -18886,17 +19074,17 @@ fn aiur_fn_188(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = []; let __cu = unconstrained; let __hit = record.function_queries[183].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[183].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[183].bump_multiplicity(__i); } let __ret: [G; OUT_183] = unsafe { *(record.function_queries[183].output_at(__i).as_ptr() as *const [G; OUT_183]) }; __ret }, _ => aiur_fn_183(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = []; let __cu = unconstrained; let __hit = record.function_queries[188].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[188].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[188].bump_multiplicity(__i); } let __ret: [G; OUT_188] = unsafe { *(record.function_queries[188].output_at(__i).as_ptr() as *const [G; OUT_188]) }; __ret }, _ => aiur_fn_188(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = []; let __cu = unconstrained; let __hit = record.function_queries[185].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[185].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[185].bump_multiplicity(__i); } let __ret: [G; OUT_185] = unsafe { *(record.function_queries[185].output_at(__i).as_ptr() as *const [G; OUT_185]) }; __ret }, _ => aiur_fn_185(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = []; let __cu = unconstrained; let __hit = record.function_queries[190].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[190].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[190].bump_multiplicity(__i); } let __ret: [G; OUT_190] = unsafe { *(record.function_queries[190].output_at(__i).as_ptr() as *const [G; OUT_190]) }; __ret }, _ => aiur_fn_190(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
-                let __ret: [G; OUT_188] = [__v_14, __v_15];
-                record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_193] = [__v_14, __v_15];
+                record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -18905,8 +19093,8 @@ fn aiur_fn_188(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_188] = [__v_14, __v_18];
-                record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_193] = [__v_14, __v_18];
+                record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -18917,8 +19105,8 @@ fn aiur_fn_188(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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, __v_16];
-            record.function_queries[188].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_193] = [__v_12, __v_16];
+            record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -18927,15 +19115,15 @@ fn aiur_fn_188(
   })
 }
 
-const INPUT_SIZE_189: usize = 1;
-const IN_189: usize = 1;
-const OUT_189: usize = 2;
-fn aiur_fn_189(
-  inp: [G; IN_189],
+const INPUT_SIZE_194: usize = 1;
+const IN_194: usize = 1;
+const OUT_194: usize = 2;
+fn aiur_fn_194(
+  inp: [G; IN_194],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_189], ExecError> {
+) -> Result<[G; OUT_194], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -18945,11 +19133,11 @@ fn aiur_fn_189(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
@@ -18961,14 +19149,14 @@ fn aiur_fn_189(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_189] = [__v_10, __v_14];
-            record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_194] = [__v_10, __v_14];
+            record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_189] = [__v_10, __v_0];
-            record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_194] = [__v_10, __v_0];
+            record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -18979,23 +19167,23 @@ fn aiur_fn_189(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_189] = [__v_5, __v_9];
-        record.function_queries[189].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_194] = [__v_5, __v_9];
+        record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_190: usize = 1;
-const IN_190: usize = 1;
-const OUT_190: usize = 2;
-fn aiur_fn_190(
-  inp: [G; IN_190],
+const INPUT_SIZE_195: usize = 1;
+const IN_195: usize = 1;
+const OUT_195: usize = 2;
+fn aiur_fn_195(
+  inp: [G; IN_195],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_190], ExecError> {
+) -> Result<[G; OUT_195], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19008,8 +19196,8 @@ fn aiur_fn_190(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_190] = [__v_5, __v_0];
-            record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_195] = [__v_5, __v_0];
+            record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -19018,8 +19206,8 @@ fn aiur_fn_190(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_190] = [__v_5, __v_9];
-            record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_195] = [__v_5, __v_9];
+            record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -19030,358 +19218,358 @@ fn aiur_fn_190(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_190] = [__v_5, __v_9];
-        record.function_queries[190].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_195] = [__v_5, __v_9];
+        record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_191: usize = 0;
-const IN_191: usize = 0;
-const OUT_191: usize = 1;
-fn aiur_fn_191(
-  inp: [G; IN_191],
+const INPUT_SIZE_196: usize = 0;
+const IN_196: usize = 0;
+const OUT_196: usize = 1;
+fn aiur_fn_196(
+  inp: [G; IN_196],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_191], ExecError> {
+) -> Result<[G; OUT_196], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(172);
-    let __v_1: G = G::from_u64(217);
-    let __v_2: G = G::from_u64(240);
-    let __v_3: G = G::from_u64(163);
-    let __v_4: G = G::from_u64(247);
-    let __v_5: G = G::from_u64(232);
-    let __v_6: G = G::from_u64(197);
-    let __v_7: G = G::from_u64(58);
-    let __v_8: G = G::from_u64(70);
-    let __v_9: G = G::from_u64(185);
-    let __v_10: G = G::from_u64(23);
-    let __v_11: G = G::from_u64(89);
-    let __v_12: G = G::from_u64(53);
-    let __v_13: G = G::from_u64(131);
-    let __v_14: G = G::from_u64(102);
-    let __v_15: G = G::from_u64(250);
-    let __v_16: G = G::from_u64(2);
-    let __v_17: G = G::from_u64(130);
-    let __v_18: G = G::from_u64(64);
-    let __v_19: G = G::from_u64(176);
-    let __v_20: G = G::from_u64(182);
-    let __v_21: G = G::from_u64(204);
-    let __v_22: G = G::from_u64(9);
-    let __v_23: G = G::from_u64(32);
-    let __v_24: G = G::from_u64(93);
-    let __v_25: G = G::from_u64(222);
-    let __v_26: G = G::from_u64(52);
-    let __v_27: G = G::from_u64(163);
-    let __v_28: G = G::from_u64(53);
-    let __v_29: G = G::from_u64(68);
-    let __v_30: G = G::from_u64(103);
-    let __v_31: G = G::from_u64(141);
+    let __v_0: G = G::from_u64(193);
+    let __v_1: G = G::from_u64(16);
+    let __v_2: G = G::from_u64(214);
+    let __v_3: G = G::from_u64(20);
+    let __v_4: G = G::from_u64(180);
+    let __v_5: G = G::from_u64(65);
+    let __v_6: G = G::from_u64(198);
+    let __v_7: G = G::from_u64(204);
+    let __v_8: G = G::from_u64(166);
+    let __v_9: G = G::from_u64(158);
+    let __v_10: G = G::from_u64(205);
+    let __v_11: G = G::from_u64(124);
+    let __v_12: G = G::from_u64(28);
+    let __v_13: G = G::from_u64(44);
+    let __v_14: G = G::from_u64(118);
+    let __v_15: G = G::from_u64(243);
+    let __v_16: G = G::from_u64(188);
+    let __v_17: G = G::from_u64(33);
+    let __v_18: G = G::from_u64(253);
+    let __v_19: G = G::from_u64(64);
+    let __v_20: G = G::from_u64(196);
+    let __v_21: G = G::from_u64(0);
+    let __v_22: G = G::from_u64(30);
+    let __v_23: G = G::from_u64(106);
+    let __v_24: G = G::from_u64(26);
+    let __v_25: G = G::from_u64(125);
+    let __v_26: G = G::from_u64(28);
+    let __v_27: G = G::from_u64(244);
+    let __v_28: G = G::from_u64(129);
+    let __v_29: G = G::from_u64(226);
+    let __v_30: G = G::from_u64(60);
+    let __v_31: G = G::from_u64(221);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_191] = [__v_32];
-    record.function_queries[191].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_196] = [__v_32];
+    record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_192: usize = 0;
-const IN_192: usize = 0;
-const OUT_192: usize = 1;
-fn aiur_fn_192(
-  inp: [G; IN_192],
+const INPUT_SIZE_197: usize = 0;
+const IN_197: usize = 0;
+const OUT_197: usize = 1;
+fn aiur_fn_197(
+  inp: [G; IN_197],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_192], ExecError> {
+) -> Result<[G; OUT_197], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(87);
-    let __v_1: G = G::from_u64(33);
-    let __v_2: G = G::from_u64(202);
-    let __v_3: G = G::from_u64(42);
-    let __v_4: G = G::from_u64(207);
-    let __v_5: G = G::from_u64(44);
-    let __v_6: G = G::from_u64(105);
-    let __v_7: G = G::from_u64(148);
-    let __v_8: G = G::from_u64(119);
-    let __v_9: G = G::from_u64(21);
-    let __v_10: G = G::from_u64(9);
-    let __v_11: G = G::from_u64(51);
-    let __v_12: G = G::from_u64(47);
-    let __v_13: G = G::from_u64(177);
-    let __v_14: G = G::from_u64(133);
-    let __v_15: G = G::from_u64(247);
-    let __v_16: G = G::from_u64(131);
-    let __v_17: G = G::from_u64(244);
-    let __v_18: G = G::from_u64(66);
-    let __v_19: G = G::from_u64(174);
-    let __v_20: G = G::from_u64(252);
-    let __v_21: G = G::from_u64(228);
-    let __v_22: G = G::from_u64(23);
-    let __v_23: G = G::from_u64(210);
-    let __v_24: G = G::from_u64(134);
-    let __v_25: G = G::from_u64(62);
-    let __v_26: G = G::from_u64(45);
-    let __v_27: G = G::from_u64(20);
-    let __v_28: G = G::from_u64(142);
-    let __v_29: G = G::from_u64(220);
-    let __v_30: G = G::from_u64(219);
-    let __v_31: G = G::from_u64(138);
+    let __v_0: G = G::from_u64(41);
+    let __v_1: G = G::from_u64(185);
+    let __v_2: G = G::from_u64(242);
+    let __v_3: G = G::from_u64(64);
+    let __v_4: G = G::from_u64(134);
+    let __v_5: G = G::from_u64(177);
+    let __v_6: G = G::from_u64(177);
+    let __v_7: G = G::from_u64(248);
+    let __v_8: G = G::from_u64(130);
+    let __v_9: G = G::from_u64(17);
+    let __v_10: G = G::from_u64(53);
+    let __v_11: G = G::from_u64(136);
+    let __v_12: G = G::from_u64(102);
+    let __v_13: G = G::from_u64(19);
+    let __v_14: G = G::from_u64(159);
+    let __v_15: G = G::from_u64(219);
+    let __v_16: G = G::from_u64(125);
+    let __v_17: G = G::from_u64(205);
+    let __v_18: G = G::from_u64(252);
+    let __v_19: G = G::from_u64(151);
+    let __v_20: G = G::from_u64(181);
+    let __v_21: G = G::from_u64(246);
+    let __v_22: G = G::from_u64(199);
+    let __v_23: G = G::from_u64(127);
+    let __v_24: G = G::from_u64(196);
+    let __v_25: G = G::from_u64(149);
+    let __v_26: G = G::from_u64(191);
+    let __v_27: G = G::from_u64(140);
+    let __v_28: G = G::from_u64(119);
+    let __v_29: G = G::from_u64(99);
+    let __v_30: G = G::from_u64(153);
+    let __v_31: G = G::from_u64(130);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_192] = [__v_32];
-    record.function_queries[192].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_197] = [__v_32];
+    record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_193: usize = 0;
-const IN_193: usize = 0;
-const OUT_193: usize = 1;
-fn aiur_fn_193(
-  inp: [G; IN_193],
+const INPUT_SIZE_198: usize = 0;
+const IN_198: usize = 0;
+const OUT_198: usize = 1;
+fn aiur_fn_198(
+  inp: [G; IN_198],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_193], ExecError> {
+) -> Result<[G; OUT_198], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(199);
-    let __v_1: G = G::from_u64(25);
-    let __v_2: G = G::from_u64(42);
-    let __v_3: G = G::from_u64(197);
-    let __v_4: G = G::from_u64(7);
-    let __v_5: G = G::from_u64(214);
-    let __v_6: G = G::from_u64(124);
-    let __v_7: G = G::from_u64(60);
-    let __v_8: G = G::from_u64(62);
-    let __v_9: G = G::from_u64(30);
-    let __v_10: G = G::from_u64(185);
-    let __v_11: G = G::from_u64(6);
-    let __v_12: G = G::from_u64(51);
-    let __v_13: G = G::from_u64(133);
-    let __v_14: G = G::from_u64(138);
-    let __v_15: G = G::from_u64(231);
-    let __v_16: G = G::from_u64(183);
-    let __v_17: G = G::from_u64(203);
-    let __v_18: G = G::from_u64(200);
-    let __v_19: G = G::from_u64(14);
+    let __v_0: G = G::from_u64(127);
+    let __v_1: G = G::from_u64(15);
+    let __v_2: G = G::from_u64(95);
+    let __v_3: G = G::from_u64(237);
+    let __v_4: G = G::from_u64(161);
+    let __v_5: G = G::from_u64(130);
+    let __v_6: G = G::from_u64(128);
+    let __v_7: G = G::from_u64(114);
+    let __v_8: G = G::from_u64(18);
+    let __v_9: G = G::from_u64(63);
+    let __v_10: G = G::from_u64(36);
+    let __v_11: G = G::from_u64(42);
+    let __v_12: G = G::from_u64(70);
+    let __v_13: G = G::from_u64(164);
+    let __v_14: G = G::from_u64(5);
+    let __v_15: G = G::from_u64(73);
+    let __v_16: G = G::from_u64(232);
+    let __v_17: G = G::from_u64(89);
+    let __v_18: G = G::from_u64(52);
+    let __v_19: G = G::from_u64(247);
     let __v_20: G = G::from_u64(57);
-    let __v_21: G = G::from_u64(136);
-    let __v_22: G = G::from_u64(49);
-    let __v_23: G = G::from_u64(38);
-    let __v_24: G = G::from_u64(24);
-    let __v_25: G = G::from_u64(199);
-    let __v_26: G = G::from_u64(236);
-    let __v_27: G = G::from_u64(9);
-    let __v_28: G = G::from_u64(180);
-    let __v_29: G = G::from_u64(131);
-    let __v_30: G = G::from_u64(176);
-    let __v_31: G = G::from_u64(74);
+    let __v_21: G = G::from_u64(94);
+    let __v_22: G = G::from_u64(79);
+    let __v_23: G = G::from_u64(147);
+    let __v_24: G = G::from_u64(246);
+    let __v_25: G = G::from_u64(93);
+    let __v_26: G = G::from_u64(218);
+    let __v_27: G = G::from_u64(78);
+    let __v_28: G = G::from_u64(72);
+    let __v_29: G = G::from_u64(9);
+    let __v_30: G = G::from_u64(243);
+    let __v_31: G = G::from_u64(37);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_193] = [__v_32];
-    record.function_queries[193].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_198] = [__v_32];
+    record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_194: usize = 0;
-const IN_194: usize = 0;
-const OUT_194: usize = 1;
-fn aiur_fn_194(
-  inp: [G; IN_194],
+const INPUT_SIZE_199: usize = 0;
+const IN_199: usize = 0;
+const OUT_199: usize = 1;
+fn aiur_fn_199(
+  inp: [G; IN_199],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_194], ExecError> {
+) -> Result<[G; OUT_199], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(141);
-    let __v_1: G = G::from_u64(87);
-    let __v_2: G = G::from_u64(199);
-    let __v_3: G = G::from_u64(198);
-    let __v_4: G = G::from_u64(174);
-    let __v_5: G = G::from_u64(225);
-    let __v_6: G = G::from_u64(186);
-    let __v_7: G = G::from_u64(81);
-    let __v_8: G = G::from_u64(13);
-    let __v_9: G = G::from_u64(50);
-    let __v_10: G = G::from_u64(8);
-    let __v_11: G = G::from_u64(221);
-    let __v_12: G = G::from_u64(196);
-    let __v_13: G = G::from_u64(176);
-    let __v_14: G = G::from_u64(138);
-    let __v_15: G = G::from_u64(131);
-    let __v_16: G = G::from_u64(180);
-    let __v_17: G = G::from_u64(67);
-    let __v_18: G = G::from_u64(25);
-    let __v_19: G = G::from_u64(246);
-    let __v_20: G = G::from_u64(175);
-    let __v_21: G = G::from_u64(142);
-    let __v_22: G = G::from_u64(224);
-    let __v_23: G = G::from_u64(155);
-    let __v_24: G = G::from_u64(57);
-    let __v_25: G = G::from_u64(64);
-    let __v_26: G = G::from_u64(208);
-    let __v_27: G = G::from_u64(221);
-    let __v_28: G = G::from_u64(237);
-    let __v_29: G = G::from_u64(206);
-    let __v_30: G = G::from_u64(30);
-    let __v_31: G = G::from_u64(182);
+    let __v_0: G = G::from_u64(147);
+    let __v_1: G = G::from_u64(1);
+    let __v_2: G = G::from_u64(216);
+    let __v_3: G = G::from_u64(80);
+    let __v_4: G = G::from_u64(189);
+    let __v_5: G = G::from_u64(226);
+    let __v_6: G = G::from_u64(70);
+    let __v_7: G = G::from_u64(148);
+    let __v_8: G = G::from_u64(11);
+    let __v_9: G = G::from_u64(123);
+    let __v_10: G = G::from_u64(62);
+    let __v_11: G = G::from_u64(129);
+    let __v_12: G = G::from_u64(231);
+    let __v_13: G = G::from_u64(134);
+    let __v_14: G = G::from_u64(247);
+    let __v_15: G = G::from_u64(241);
+    let __v_16: G = G::from_u64(43);
+    let __v_17: G = G::from_u64(174);
+    let __v_18: G = G::from_u64(142);
+    let __v_19: G = G::from_u64(92);
+    let __v_20: G = G::from_u64(234);
+    let __v_21: G = G::from_u64(107);
+    let __v_22: G = G::from_u64(63);
+    let __v_23: G = G::from_u64(64);
+    let __v_24: G = G::from_u64(64);
+    let __v_25: G = G::from_u64(6);
+    let __v_26: G = G::from_u64(11);
+    let __v_27: G = G::from_u64(58);
+    let __v_28: G = G::from_u64(127);
+    let __v_29: G = G::from_u64(89);
+    let __v_30: G = G::from_u64(85);
+    let __v_31: G = G::from_u64(124);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_194] = [__v_32];
-    record.function_queries[194].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_199] = [__v_32];
+    record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_195: usize = 0;
-const IN_195: usize = 0;
-const OUT_195: usize = 1;
-fn aiur_fn_195(
-  inp: [G; IN_195],
+const INPUT_SIZE_200: usize = 0;
+const IN_200: usize = 0;
+const OUT_200: usize = 1;
+fn aiur_fn_200(
+  inp: [G; IN_200],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_195], ExecError> {
+) -> Result<[G; OUT_200], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(209);
-    let __v_1: G = G::from_u64(16);
-    let __v_2: G = G::from_u64(124);
-    let __v_3: G = G::from_u64(153);
-    let __v_4: G = G::from_u64(173);
-    let __v_5: G = G::from_u64(158);
-    let __v_6: G = G::from_u64(188);
-    let __v_7: G = G::from_u64(181);
-    let __v_8: G = G::from_u64(2);
-    let __v_9: G = G::from_u64(141);
-    let __v_10: G = G::from_u64(154);
-    let __v_11: G = G::from_u64(234);
-    let __v_12: G = G::from_u64(13);
-    let __v_13: G = G::from_u64(165);
-    let __v_14: G = G::from_u64(33);
-    let __v_15: G = G::from_u64(237);
-    let __v_16: G = G::from_u64(92);
-    let __v_17: G = G::from_u64(18);
-    let __v_18: G = G::from_u64(231);
-    let __v_19: G = G::from_u64(30);
-    let __v_20: G = G::from_u64(162);
-    let __v_21: G = G::from_u64(236);
-    let __v_22: G = G::from_u64(222);
-    let __v_23: G = G::from_u64(175);
-    let __v_24: G = G::from_u64(99);
-    let __v_25: G = G::from_u64(123);
-    let __v_26: G = G::from_u64(180);
-    let __v_27: G = G::from_u64(161);
-    let __v_28: G = G::from_u64(77);
-    let __v_29: G = G::from_u64(74);
-    let __v_30: G = G::from_u64(126);
-    let __v_31: G = G::from_u64(68);
+    let __v_0: G = G::from_u64(32);
+    let __v_1: G = G::from_u64(232);
+    let __v_2: G = G::from_u64(144);
+    let __v_3: G = G::from_u64(98);
+    let __v_4: G = G::from_u64(128);
+    let __v_5: G = G::from_u64(180);
+    let __v_6: G = G::from_u64(220);
+    let __v_7: G = G::from_u64(215);
+    let __v_8: G = G::from_u64(74);
+    let __v_9: G = G::from_u64(122);
+    let __v_10: G = G::from_u64(120);
+    let __v_11: G = G::from_u64(224);
+    let __v_12: G = G::from_u64(109);
+    let __v_13: G = G::from_u64(88);
+    let __v_14: G = G::from_u64(14);
+    let __v_15: G = G::from_u64(111);
+    let __v_16: G = G::from_u64(0);
+    let __v_17: G = G::from_u64(238);
+    let __v_18: G = G::from_u64(187);
+    let __v_19: G = G::from_u64(169);
+    let __v_20: G = G::from_u64(252);
+    let __v_21: G = G::from_u64(64);
+    let __v_22: G = G::from_u64(120);
+    let __v_23: G = G::from_u64(146);
+    let __v_24: G = G::from_u64(98);
+    let __v_25: G = G::from_u64(233);
+    let __v_26: G = G::from_u64(92);
+    let __v_27: G = G::from_u64(172);
+    let __v_28: G = G::from_u64(182);
+    let __v_29: G = G::from_u64(240);
+    let __v_30: G = G::from_u64(214);
+    let __v_31: G = G::from_u64(153);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_195] = [__v_32];
-    record.function_queries[195].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_200] = [__v_32];
+    record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_196: usize = 0;
-const IN_196: usize = 0;
-const OUT_196: usize = 1;
-fn aiur_fn_196(
-  inp: [G; IN_196],
+const INPUT_SIZE_201: usize = 0;
+const IN_201: usize = 0;
+const OUT_201: usize = 1;
+fn aiur_fn_201(
+  inp: [G; IN_201],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_196], ExecError> {
+) -> Result<[G; OUT_201], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(198);
-    let __v_1: G = G::from_u64(157);
-    let __v_2: G = G::from_u64(244);
+    let __v_0: G = G::from_u64(72);
+    let __v_1: G = G::from_u64(2);
+    let __v_2: G = G::from_u64(177);
     let __v_3: G = G::from_u64(131);
-    let __v_4: G = G::from_u64(62);
-    let __v_5: G = G::from_u64(205);
-    let __v_6: G = G::from_u64(206);
-    let __v_7: G = G::from_u64(118);
-    let __v_8: G = G::from_u64(189);
-    let __v_9: G = G::from_u64(176);
-    let __v_10: G = G::from_u64(210);
-    let __v_11: G = G::from_u64(49);
-    let __v_12: G = G::from_u64(89);
-    let __v_13: G = G::from_u64(225);
-    let __v_14: G = G::from_u64(250);
-    let __v_15: G = G::from_u64(198);
-    let __v_16: G = G::from_u64(82);
-    let __v_17: G = G::from_u64(216);
-    let __v_18: G = G::from_u64(137);
-    let __v_19: G = G::from_u64(25);
-    let __v_20: G = G::from_u64(118);
-    let __v_21: G = G::from_u64(140);
-    let __v_22: G = G::from_u64(49);
-    let __v_23: G = G::from_u64(44);
-    let __v_24: G = G::from_u64(102);
-    let __v_25: G = G::from_u64(17);
-    let __v_26: G = G::from_u64(220);
-    let __v_27: G = G::from_u64(6);
-    let __v_28: G = G::from_u64(13);
-    let __v_29: G = G::from_u64(161);
-    let __v_30: G = G::from_u64(111);
-    let __v_31: G = G::from_u64(4);
+    let __v_4: G = G::from_u64(244);
+    let __v_5: G = G::from_u64(214);
+    let __v_6: G = G::from_u64(220);
+    let __v_7: G = G::from_u64(204);
+    let __v_8: G = G::from_u64(172);
+    let __v_9: G = G::from_u64(186);
+    let __v_10: G = G::from_u64(87);
+    let __v_11: G = G::from_u64(114);
+    let __v_12: G = G::from_u64(24);
+    let __v_13: G = G::from_u64(36);
+    let __v_14: G = G::from_u64(167);
+    let __v_15: G = G::from_u64(187);
+    let __v_16: G = G::from_u64(103);
+    let __v_17: G = G::from_u64(218);
+    let __v_18: G = G::from_u64(235);
+    let __v_19: G = G::from_u64(39);
+    let __v_20: G = G::from_u64(37);
+    let __v_21: G = G::from_u64(218);
+    let __v_22: G = G::from_u64(23);
+    let __v_23: G = G::from_u64(35);
+    let __v_24: G = G::from_u64(146);
+    let __v_25: G = G::from_u64(113);
+    let __v_26: G = G::from_u64(193);
+    let __v_27: G = G::from_u64(53);
+    let __v_28: G = G::from_u64(149);
+    let __v_29: G = G::from_u64(44);
+    let __v_30: G = G::from_u64(170);
+    let __v_31: G = G::from_u64(97);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_196] = [__v_32];
-    record.function_queries[196].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_201] = [__v_32];
+    record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_197: usize = 1;
-const IN_197: usize = 1;
-const OUT_197: usize = 1;
-fn aiur_fn_197(
-  inp: [G; IN_197],
+const INPUT_SIZE_202: usize = 1;
+const IN_202: usize = 1;
+const OUT_202: usize = 1;
+fn aiur_fn_202(
+  inp: [G; IN_202],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_197], ExecError> {
+) -> Result<[G; OUT_202], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_197] = [__v_3];
-        record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_202] = [__v_3];
+        record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_197] = [__v_5];
-            record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_202] = [__v_5];
+            record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = []; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_197] = [__v_7];
-                record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_202] = [__v_7];
+                record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_197] = [__v_7];
-                record.function_queries[197].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_202] = [__v_7];
+                record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -19392,61 +19580,61 @@ fn aiur_fn_197(
   })
 }
 
-const INPUT_SIZE_198: usize = 1;
-const IN_198: usize = 1;
-const OUT_198: usize = 1;
-fn aiur_fn_198(
-  inp: [G; IN_198],
+const INPUT_SIZE_203: usize = 1;
+const IN_203: usize = 1;
+const OUT_203: usize = 1;
+fn aiur_fn_203(
+  inp: [G; IN_203],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_198], ExecError> {
+) -> Result<[G; OUT_203], 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(2);
-        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_198] = [__v_7];
-        record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_203] = [__v_7];
+        record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(2);
-        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_198] = [__v_7];
-        record.function_queries[198].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_203] = [__v_7];
+        record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_199: usize = 2;
-const IN_199: usize = 2;
-const OUT_199: usize = 2;
-fn aiur_fn_199(
-  inp: [G; IN_199],
+const INPUT_SIZE_204: usize = 2;
+const IN_204: usize = 2;
+const OUT_204: usize = 2;
+fn aiur_fn_204(
+  inp: [G; IN_204],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_199], ExecError> {
+) -> Result<[G; OUT_204], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__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];
@@ -19456,12 +19644,12 @@ fn aiur_fn_199(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_199] = [__v_5, __v_8];
-        record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_204] = [__v_5, __v_8];
+        record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
         match __v_5.as_canonical_u64() {
@@ -19470,12 +19658,12 @@ fn aiur_fn_199(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_199] = [__v_7, __v_10];
-            record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_204] = [__v_7, __v_10];
+            record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
             match __v_7.as_canonical_u64() {
@@ -19484,8 +19672,8 @@ fn aiur_fn_199(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_199] = [__v_9, __v_12];
-                record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_204] = [__v_9, __v_12];
+                record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
@@ -19502,15 +19690,15 @@ fn aiur_fn_199(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_21, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_21, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__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_136] = { let __args: [G; IN_136] = [__v_6, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_6, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } };
                 let __v_24: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
-                let __ret: [G; OUT_199] = [__v_23, __v_25];
-                record.function_queries[199].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_204] = [__v_23, __v_25];
+                record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -19530,18 +19718,18 @@ fn aiur_fn_199(
   })
 }
 
-const INPUT_SIZE_200: usize = 1;
-const IN_200: usize = 1;
-const OUT_200: usize = 2;
-fn aiur_fn_200(
-  inp: [G; IN_200],
+const INPUT_SIZE_205: usize = 1;
+const IN_205: usize = 1;
+const OUT_205: usize = 2;
+fn aiur_fn_205(
+  inp: [G; IN_205],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_200], ExecError> {
+) -> Result<[G; OUT_205], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -19552,21 +19740,21 @@ fn aiur_fn_200(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_200] = [__v_4, __v_8];
-        record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_205] = [__v_4, __v_8];
+        record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = __r_arr[1];
         match __v_10.as_canonical_u64() {
@@ -19576,12 +19764,12 @@ fn aiur_fn_200(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_200] = [__v_12, __v_16];
-            record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_205] = [__v_12, __v_16];
+            record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
@@ -19591,20 +19779,20 @@ fn aiur_fn_200(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_200] = [__v_14, __v_18];
-                record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_205] = [__v_14, __v_18];
+                record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
                 let __v_16: G = (__v_14 - __v_15);
                 let __v_17: G = G::from_u64(1);
-                let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_200] = [__v_17, __v_18];
-                record.function_queries[200].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_205] = [__v_17, __v_18];
+                record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -19621,18 +19809,18 @@ fn aiur_fn_200(
   })
 }
 
-const INPUT_SIZE_201: usize = 1;
-const IN_201: usize = 1;
-const OUT_201: usize = 2;
-fn aiur_fn_201(
-  inp: [G; IN_201],
+const INPUT_SIZE_206: usize = 1;
+const IN_206: usize = 1;
+const OUT_206: usize = 2;
+fn aiur_fn_206(
+  inp: [G; IN_206],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_201], ExecError> {
+) -> Result<[G; OUT_206], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -19643,15 +19831,15 @@ fn aiur_fn_201(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_201] = [__v_4, __v_8];
-        record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_206] = [__v_4, __v_8];
+        record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19661,7 +19849,7 @@ fn aiur_fn_201(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = []; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_9, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
@@ -19672,12 +19860,12 @@ fn aiur_fn_201(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_201] = [__v_14, __v_18];
-                record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_206] = [__v_14, __v_18];
+                record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -19688,15 +19876,15 @@ fn aiur_fn_201(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_201] = [__v_17, __v_21];
-                    record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_206] = [__v_17, __v_21];
+                    record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_17: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_7, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19706,7 +19894,7 @@ fn aiur_fn_201(
                     let __v_24: G = __loaded[3];
                     match __v_21.as_canonical_u64() {
                       2u64 => {
-                        let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = []; let __cu = unconstrained; let __hit = record.function_queries[193].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[193].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[193].bump_multiplicity(__i); } let __ret: [G; OUT_193] = unsafe { *(record.function_queries[193].output_at(__i).as_ptr() as *const [G; OUT_193]) }; __ret }, _ => aiur_fn_193(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = []; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } };
                         let __v_25: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_22, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_26: G = __r_arr[0];
@@ -19717,12 +19905,12 @@ fn aiur_fn_201(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_201] = [__v_27, __v_31];
-                            record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_206] = [__v_27, __v_31];
+                            record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -19733,19 +19921,19 @@ fn aiur_fn_201(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_201] = [__v_30, __v_34];
-                                record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_206] = [__v_30, __v_34];
+                                record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_30: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_20, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_20, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_7, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_7, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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);
@@ -19756,11 +19944,11 @@ fn aiur_fn_201(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } };
                                 let __v_45: G = __r_arr[0];
                                 let __v_46: G = __r_arr[1];
-                                let __ret: [G; OUT_201] = [__v_45, __v_46];
-                                record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_206] = [__v_45, __v_46];
+                                record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -19773,8 +19961,8 @@ fn aiur_fn_201(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_201] = [__v_25, __v_29];
-                        record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_206] = [__v_25, __v_29];
+                        record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -19789,8 +19977,8 @@ fn aiur_fn_201(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_201] = [__v_12, __v_16];
-            record.function_queries[201].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_206] = [__v_12, __v_16];
+            record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -19799,18 +19987,18 @@ fn aiur_fn_201(
   })
 }
 
-const INPUT_SIZE_202: usize = 1;
-const IN_202: usize = 1;
-const OUT_202: usize = 3;
-fn aiur_fn_202(
-  inp: [G; IN_202],
+const INPUT_SIZE_207: usize = 1;
+const IN_207: usize = 1;
+const OUT_207: usize = 3;
+fn aiur_fn_207(
+  inp: [G; IN_207],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_202], ExecError> {
+) -> Result<[G; OUT_207], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -19820,13 +20008,13 @@ fn aiur_fn_202(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = []; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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);
@@ -19834,13 +20022,13 @@ fn aiur_fn_202(
               0u64 => {
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_202] = [__v_12, __v_14, __v_16];
-                record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_207] = [__v_12, __v_14, __v_16];
+                record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -19853,8 +20041,8 @@ fn aiur_fn_202(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_202] = [__v_12, __v_16, __v_20];
-                record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_207] = [__v_12, __v_16, __v_20];
+                record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -19869,8 +20057,8 @@ fn aiur_fn_202(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_202] = [__v_9, __v_13, __v_17];
-            record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_207] = [__v_9, __v_13, __v_17];
+            record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -19885,34 +20073,34 @@ fn aiur_fn_202(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_202] = [__v_7, __v_11, __v_15];
-        record.function_queries[202].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_207] = [__v_7, __v_11, __v_15];
+        record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_203: usize = 3;
-const IN_203: usize = 3;
-const OUT_203: usize = 2;
-fn aiur_fn_203(
-  inp: [G; IN_203],
+const INPUT_SIZE_208: usize = 3;
+const IN_208: usize = 3;
+const OUT_208: usize = 2;
+fn aiur_fn_208(
+  inp: [G; IN_208],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_203], ExecError> {
+) -> Result<[G; OUT_208], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = []; let __cu = unconstrained; let __hit = record.function_queries[191].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[191].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[191].bump_multiplicity(__i); } let __ret: [G; OUT_191] = unsafe { *(record.function_queries[191].output_at(__i).as_ptr() as *const [G; OUT_191]) }; __ret }, _ => aiur_fn_191(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; let __hit = record.function_queries[196].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[196].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[196].bump_multiplicity(__i); } let __ret: [G; OUT_196] = unsafe { *(record.function_queries[196].output_at(__i).as_ptr() as *const [G; OUT_196]) }; __ret }, _ => aiur_fn_196(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -19923,20 +20111,20 @@ fn aiur_fn_203(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_203] = [__v_8, __v_12];
-            record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_208] = [__v_8, __v_12];
+            record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[389].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { *(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389]) }; __ret }, _ => aiur_fn_389(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[394].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[394].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[394].bump_multiplicity(__i); } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => aiur_fn_394(__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_777] = { let __args: [G; IN_777] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(1);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             match __v_13.as_canonical_u64() {
@@ -19946,16 +20134,16 @@ fn aiur_fn_203(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_203] = [__v_15, __v_19];
-                record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_208] = [__v_15, __v_19];
+                record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_203] = [__v_15, __v_16];
-                record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_208] = [__v_15, __v_16];
+                record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -19966,33 +20154,33 @@ fn aiur_fn_203(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = []; let __cu = unconstrained; let __hit = record.function_queries[194].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[194].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[194].bump_multiplicity(__i); } let __ret: [G; OUT_194] = unsafe { *(record.function_queries[194].output_at(__i).as_ptr() as *const [G; OUT_194]) }; __ret }, _ => aiur_fn_194(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = []; let __cu = unconstrained; let __hit = record.function_queries[199].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[199].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[199].bump_multiplicity(__i); } let __ret: [G; OUT_199] = unsafe { *(record.function_queries[199].output_at(__i).as_ptr() as *const [G; OUT_199]) }; __ret }, _ => aiur_fn_199(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[204].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[204].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[204].bump_multiplicity(__i); } let __ret: [G; OUT_204] = unsafe { *(record.function_queries[204].output_at(__i).as_ptr() as *const [G; OUT_204]) }; __ret }, _ => aiur_fn_204(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_203] = [__v_8, __v_9];
-            record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_208] = [__v_8, __v_9];
+            record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = []; let __cu = unconstrained; let __hit = record.function_queries[195].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[195].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[195].bump_multiplicity(__i); } let __ret: [G; OUT_195] = unsafe { *(record.function_queries[195].output_at(__i).as_ptr() as *const [G; OUT_195]) }; __ret }, _ => aiur_fn_195(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = []; let __cu = unconstrained; let __hit = record.function_queries[200].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[200].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[200].bump_multiplicity(__i); } let __ret: [G; OUT_200] = unsafe { *(record.function_queries[200].output_at(__i).as_ptr() as *const [G; OUT_200]) }; __ret }, _ => aiur_fn_200(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[201].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[201].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[201].bump_multiplicity(__i); } let __ret: [G; OUT_201] = unsafe { *(record.function_queries[201].output_at(__i).as_ptr() as *const [G; OUT_201]) }; __ret }, _ => aiur_fn_201(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __v_10: G = __r_arr[1];
-                let __ret: [G; OUT_203] = [__v_9, __v_10];
-                record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_208] = [__v_9, __v_10];
+                record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -20001,8 +20189,8 @@ fn aiur_fn_203(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_203] = [__v_9, __v_13];
-                record.function_queries[203].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_208] = [__v_9, __v_13];
+                record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -20013,19 +20201,19 @@ fn aiur_fn_203(
   })
 }
 
-const INPUT_SIZE_204: usize = 2;
-const IN_204: usize = 2;
-const OUT_204: usize = 1;
-fn aiur_fn_204(
-  inp: [G; IN_204],
+const INPUT_SIZE_209: usize = 2;
+const IN_209: usize = 2;
+const OUT_209: usize = 1;
+fn aiur_fn_209(
+  inp: [G; IN_209],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_204], ExecError> {
+) -> Result<[G; OUT_209], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -20033,8 +20221,8 @@ fn aiur_fn_204(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_204] = [__v_2];
-        record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_209] = [__v_2];
+        record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -20044,8 +20232,8 @@ fn aiur_fn_204(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_204] = [__v_2];
-            record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_209] = [__v_2];
+            record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -20055,14 +20243,14 @@ fn aiur_fn_204(
             let __v_11: G = __loaded[2];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_204] = [__v_2];
-                record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_209] = [__v_2];
+                record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
-                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_205] = { let __args: [G; IN_205] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[205].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[205].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[205].bump_multiplicity(__i); } let __ret: [G; OUT_205] = unsafe { *(record.function_queries[205].output_at(__i).as_ptr() as *const [G; OUT_205]) }; __ret }, _ => aiur_fn_205(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__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);
@@ -20070,8 +20258,8 @@ fn aiur_fn_204(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_204] = [__v_19];
-                record.function_queries[204].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_209] = [__v_19];
+                record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -20091,271 +20279,26 @@ fn aiur_fn_204(
   })
 }
 
-const INPUT_SIZE_205: usize = 2;
-const IN_205: usize = 2;
-const OUT_205: usize = 1;
-fn aiur_fn_205(
-  inp: [G; IN_205],
+const INPUT_SIZE_210: usize = 2;
+const IN_210: usize = 2;
+const OUT_210: usize = 1;
+fn aiur_fn_210(
+  inp: [G; IN_210],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_205], ExecError> {
+) -> Result<[G; OUT_210], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_205] = [__v_5];
-    record.function_queries[205].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_206: usize = 0;
-const IN_206: usize = 0;
-const OUT_206: usize = 1;
-fn aiur_fn_206(
-  inp: [G; IN_206],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_206], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(177);
-    let __v_1: G = G::from_u64(246);
-    let __v_2: G = G::from_u64(240);
-    let __v_3: G = G::from_u64(75);
-    let __v_4: G = G::from_u64(222);
-    let __v_5: G = G::from_u64(61);
-    let __v_6: G = G::from_u64(129);
-    let __v_7: G = G::from_u64(249);
-    let __v_8: G = G::from_u64(16);
-    let __v_9: G = G::from_u64(46);
-    let __v_10: G = G::from_u64(166);
-    let __v_11: G = G::from_u64(183);
-    let __v_12: G = G::from_u64(210);
-    let __v_13: G = G::from_u64(201);
-    let __v_14: G = G::from_u64(244);
-    let __v_15: G = G::from_u64(35);
-    let __v_16: G = G::from_u64(109);
-    let __v_17: G = G::from_u64(114);
-    let __v_18: G = G::from_u64(177);
-    let __v_19: G = G::from_u64(126);
-    let __v_20: G = G::from_u64(1);
-    let __v_21: G = G::from_u64(18);
-    let __v_22: G = G::from_u64(85);
-    let __v_23: G = G::from_u64(35);
-    let __v_24: G = G::from_u64(197);
-    let __v_25: G = G::from_u64(213);
-    let __v_26: G = G::from_u64(226);
-    let __v_27: G = G::from_u64(97);
-    let __v_28: G = G::from_u64(175);
-    let __v_29: G = G::from_u64(199);
-    let __v_30: G = G::from_u64(17);
-    let __v_31: G = G::from_u64(5);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_206] = [__v_32];
-    record.function_queries[206].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_207: usize = 0;
-const IN_207: usize = 0;
-const OUT_207: usize = 1;
-fn aiur_fn_207(
-  inp: [G; IN_207],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_207], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(182);
-    let __v_1: G = G::from_u64(236);
-    let __v_2: G = G::from_u64(45);
-    let __v_3: G = G::from_u64(68);
-    let __v_4: G = G::from_u64(63);
-    let __v_5: G = G::from_u64(62);
-    let __v_6: G = G::from_u64(230);
-    let __v_7: G = G::from_u64(29);
-    let __v_8: G = G::from_u64(228);
-    let __v_9: G = G::from_u64(90);
-    let __v_10: G = G::from_u64(216);
-    let __v_11: G = G::from_u64(89);
-    let __v_12: G = G::from_u64(184);
-    let __v_13: G = G::from_u64(204);
-    let __v_14: G = G::from_u64(65);
-    let __v_15: G = G::from_u64(168);
-    let __v_16: G = G::from_u64(150);
-    let __v_17: G = G::from_u64(216);
-    let __v_18: G = G::from_u64(251);
-    let __v_19: G = G::from_u64(164);
-    let __v_20: G = G::from_u64(155);
-    let __v_21: G = G::from_u64(194);
-    let __v_22: G = G::from_u64(152);
-    let __v_23: G = G::from_u64(131);
-    let __v_24: G = G::from_u64(252);
-    let __v_25: G = G::from_u64(52);
-    let __v_26: G = G::from_u64(196);
-    let __v_27: G = G::from_u64(39);
-    let __v_28: G = G::from_u64(219);
-    let __v_29: G = G::from_u64(223);
-    let __v_30: G = G::from_u64(113);
-    let __v_31: G = G::from_u64(248);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_207] = [__v_32];
-    record.function_queries[207].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_208: usize = 0;
-const IN_208: usize = 0;
-const OUT_208: usize = 1;
-fn aiur_fn_208(
-  inp: [G; IN_208],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_208], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(213);
-    let __v_1: G = G::from_u64(77);
-    let __v_2: G = G::from_u64(183);
-    let __v_3: G = G::from_u64(31);
-    let __v_4: G = G::from_u64(238);
-    let __v_5: G = G::from_u64(85);
-    let __v_6: G = G::from_u64(49);
-    let __v_7: G = G::from_u64(26);
-    let __v_8: G = G::from_u64(175);
-    let __v_9: G = G::from_u64(238);
-    let __v_10: G = G::from_u64(173);
-    let __v_11: G = G::from_u64(116);
-    let __v_12: G = G::from_u64(118);
-    let __v_13: G = G::from_u64(142);
-    let __v_14: G = G::from_u64(110);
-    let __v_15: G = G::from_u64(149);
-    let __v_16: G = G::from_u64(34);
-    let __v_17: G = G::from_u64(98);
-    let __v_18: G = G::from_u64(194);
-    let __v_19: G = G::from_u64(154);
-    let __v_20: G = G::from_u64(189);
-    let __v_21: G = G::from_u64(36);
-    let __v_22: G = G::from_u64(185);
-    let __v_23: G = G::from_u64(49);
-    let __v_24: G = G::from_u64(159);
-    let __v_25: G = G::from_u64(166);
-    let __v_26: G = G::from_u64(133);
-    let __v_27: G = G::from_u64(148);
-    let __v_28: G = G::from_u64(129);
-    let __v_29: G = G::from_u64(221);
-    let __v_30: G = G::from_u64(68);
-    let __v_31: G = G::from_u64(184);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_208] = [__v_32];
-    record.function_queries[208].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_209: usize = 0;
-const IN_209: usize = 0;
-const OUT_209: usize = 1;
-fn aiur_fn_209(
-  inp: [G; IN_209],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_209], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(41);
-    let __v_1: G = G::from_u64(86);
-    let __v_2: G = G::from_u64(61);
-    let __v_3: G = G::from_u64(162);
-    let __v_4: G = G::from_u64(113);
-    let __v_5: G = G::from_u64(194);
-    let __v_6: G = G::from_u64(63);
-    let __v_7: G = G::from_u64(102);
-    let __v_8: G = G::from_u64(178);
-    let __v_9: G = G::from_u64(125);
-    let __v_10: G = G::from_u64(5);
-    let __v_11: G = G::from_u64(249);
-    let __v_12: G = G::from_u64(36);
-    let __v_13: G = G::from_u64(251);
-    let __v_14: G = G::from_u64(6);
-    let __v_15: G = G::from_u64(18);
-    let __v_16: G = G::from_u64(39);
-    let __v_17: G = G::from_u64(45);
-    let __v_18: G = G::from_u64(207);
-    let __v_19: G = G::from_u64(186);
-    let __v_20: G = G::from_u64(107);
-    let __v_21: G = G::from_u64(16);
-    let __v_22: G = G::from_u64(131);
-    let __v_23: G = G::from_u64(179);
-    let __v_24: G = G::from_u64(72);
-    let __v_25: G = G::from_u64(115);
-    let __v_26: G = G::from_u64(62);
-    let __v_27: G = G::from_u64(0);
-    let __v_28: G = G::from_u64(249);
-    let __v_29: G = G::from_u64(179);
-    let __v_30: G = G::from_u64(107);
-    let __v_31: G = G::from_u64(42);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_209] = [__v_32];
-    record.function_queries[209].finish(&inp[..], &__ret[..], !unconstrained);
-    return Ok(__ret);
-  })
-}
-
-const INPUT_SIZE_210: usize = 0;
-const IN_210: usize = 0;
-const OUT_210: usize = 1;
-fn aiur_fn_210(
-  inp: [G; IN_210],
-  record: &mut QueryRecord,
-  io_buffer: &mut IOBuffer,
-  unconstrained: bool,
-) -> Result<[G; OUT_210], ExecError> {
-  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(60);
-    let __v_1: G = G::from_u64(1);
-    let __v_2: G = G::from_u64(73);
-    let __v_3: G = G::from_u64(195);
-    let __v_4: G = G::from_u64(67);
-    let __v_5: G = G::from_u64(41);
-    let __v_6: G = G::from_u64(105);
-    let __v_7: G = G::from_u64(238);
-    let __v_8: G = G::from_u64(93);
-    let __v_9: G = G::from_u64(147);
-    let __v_10: G = G::from_u64(84);
-    let __v_11: G = G::from_u64(200);
-    let __v_12: G = G::from_u64(210);
-    let __v_13: G = G::from_u64(216);
-    let __v_14: G = G::from_u64(156);
-    let __v_15: G = G::from_u64(238);
-    let __v_16: G = G::from_u64(196);
-    let __v_17: G = G::from_u64(167);
-    let __v_18: G = G::from_u64(151);
-    let __v_19: G = G::from_u64(17);
-    let __v_20: G = G::from_u64(248);
-    let __v_21: G = G::from_u64(222);
-    let __v_22: G = G::from_u64(200);
-    let __v_23: G = G::from_u64(113);
-    let __v_24: G = G::from_u64(8);
-    let __v_25: G = G::from_u64(121);
-    let __v_26: G = G::from_u64(161);
-    let __v_27: G = G::from_u64(42);
-    let __v_28: G = G::from_u64(18);
-    let __v_29: G = G::from_u64(183);
-    let __v_30: G = G::from_u64(44);
-    let __v_31: G = G::from_u64(66);
-    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_210] = [__v_32];
+    let __ret: [G; OUT_210] = [__v_5];
     record.function_queries[210].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
@@ -20371,38 +20314,38 @@ fn aiur_fn_211(
   unconstrained: bool,
 ) -> Result<[G; OUT_211], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(209);
-    let __v_1: G = G::from_u64(224);
-    let __v_2: G = G::from_u64(128);
-    let __v_3: G = G::from_u64(44);
-    let __v_4: G = G::from_u64(56);
-    let __v_5: G = G::from_u64(188);
-    let __v_6: G = G::from_u64(218);
-    let __v_7: G = G::from_u64(20);
-    let __v_8: G = G::from_u64(6);
-    let __v_9: G = G::from_u64(30);
-    let __v_10: G = G::from_u64(32);
-    let __v_11: G = G::from_u64(18);
-    let __v_12: G = G::from_u64(241);
-    let __v_13: G = G::from_u64(46);
-    let __v_14: G = G::from_u64(115);
-    let __v_15: G = G::from_u64(194);
-    let __v_16: G = G::from_u64(162);
-    let __v_17: G = G::from_u64(74);
-    let __v_18: G = G::from_u64(103);
-    let __v_19: G = G::from_u64(17);
-    let __v_20: G = G::from_u64(55);
-    let __v_21: G = G::from_u64(152);
-    let __v_22: G = G::from_u64(79);
-    let __v_23: G = G::from_u64(142);
-    let __v_24: G = G::from_u64(247);
-    let __v_25: G = G::from_u64(103);
-    let __v_26: G = G::from_u64(68);
-    let __v_27: G = G::from_u64(234);
-    let __v_28: G = G::from_u64(4);
-    let __v_29: G = G::from_u64(209);
-    let __v_30: G = G::from_u64(136);
-    let __v_31: G = G::from_u64(196);
+    let __v_0: G = G::from_u64(82);
+    let __v_1: G = G::from_u64(176);
+    let __v_2: G = G::from_u64(34);
+    let __v_3: G = G::from_u64(110);
+    let __v_4: G = G::from_u64(161);
+    let __v_5: G = G::from_u64(76);
+    let __v_6: G = G::from_u64(148);
+    let __v_7: G = G::from_u64(177);
+    let __v_8: G = G::from_u64(249);
+    let __v_9: G = G::from_u64(51);
+    let __v_10: G = G::from_u64(76);
+    let __v_11: G = G::from_u64(153);
+    let __v_12: G = G::from_u64(87);
+    let __v_13: G = G::from_u64(245);
+    let __v_14: G = G::from_u64(88);
+    let __v_15: G = G::from_u64(147);
+    let __v_16: G = G::from_u64(153);
+    let __v_17: G = G::from_u64(168);
+    let __v_18: G = G::from_u64(107);
+    let __v_19: G = G::from_u64(205);
+    let __v_20: G = G::from_u64(174);
+    let __v_21: G = G::from_u64(17);
+    let __v_22: G = G::from_u64(31);
+    let __v_23: G = G::from_u64(40);
+    let __v_24: G = G::from_u64(71);
+    let __v_25: G = G::from_u64(201);
+    let __v_26: G = G::from_u64(176);
+    let __v_27: G = G::from_u64(194);
+    let __v_28: G = G::from_u64(251);
+    let __v_29: G = G::from_u64(10);
+    let __v_30: G = G::from_u64(34);
+    let __v_31: G = G::from_u64(97);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_211] = [__v_32];
     record.function_queries[211].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20420,38 +20363,38 @@ fn aiur_fn_212(
   unconstrained: bool,
 ) -> Result<[G; OUT_212], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(213);
-    let __v_1: G = G::from_u64(84);
-    let __v_2: G = G::from_u64(41);
-    let __v_3: G = G::from_u64(114);
-    let __v_4: G = G::from_u64(90);
-    let __v_5: G = G::from_u64(25);
-    let __v_6: G = G::from_u64(193);
-    let __v_7: G = G::from_u64(131);
-    let __v_8: G = G::from_u64(123);
-    let __v_9: G = G::from_u64(52);
-    let __v_10: G = G::from_u64(98);
-    let __v_11: G = G::from_u64(79);
-    let __v_12: G = G::from_u64(179);
-    let __v_13: G = G::from_u64(87);
-    let __v_14: G = G::from_u64(132);
-    let __v_15: G = G::from_u64(185);
-    let __v_16: G = G::from_u64(27);
-    let __v_17: G = G::from_u64(200);
-    let __v_18: G = G::from_u64(176);
-    let __v_19: G = G::from_u64(226);
-    let __v_20: G = G::from_u64(215);
-    let __v_21: G = G::from_u64(159);
-    let __v_22: G = G::from_u64(152);
-    let __v_23: G = G::from_u64(179);
-    let __v_24: G = G::from_u64(194);
-    let __v_25: G = G::from_u64(150);
-    let __v_26: G = G::from_u64(49);
-    let __v_27: G = G::from_u64(127);
-    let __v_28: G = G::from_u64(182);
-    let __v_29: G = G::from_u64(197);
-    let __v_30: G = G::from_u64(199);
-    let __v_31: G = G::from_u64(137);
+    let __v_0: G = G::from_u64(19);
+    let __v_1: G = G::from_u64(47);
+    let __v_2: G = G::from_u64(17);
+    let __v_3: G = G::from_u64(117);
+    let __v_4: G = G::from_u64(204);
+    let __v_5: G = G::from_u64(60);
+    let __v_6: G = G::from_u64(172);
+    let __v_7: G = G::from_u64(90);
+    let __v_8: G = G::from_u64(62);
+    let __v_9: G = G::from_u64(61);
+    let __v_10: G = G::from_u64(116);
+    let __v_11: G = G::from_u64(232);
+    let __v_12: G = G::from_u64(121);
+    let __v_13: G = G::from_u64(127);
+    let __v_14: G = G::from_u64(155);
+    let __v_15: G = G::from_u64(166);
+    let __v_16: G = G::from_u64(127);
+    let __v_17: G = G::from_u64(46);
+    let __v_18: G = G::from_u64(70);
+    let __v_19: G = G::from_u64(123);
+    let __v_20: G = G::from_u64(128);
+    let __v_21: G = G::from_u64(4);
+    let __v_22: G = G::from_u64(163);
+    let __v_23: G = G::from_u64(242);
+    let __v_24: G = G::from_u64(139);
+    let __v_25: G = G::from_u64(181);
+    let __v_26: G = G::from_u64(223);
+    let __v_27: G = G::from_u64(209);
+    let __v_28: G = G::from_u64(106);
+    let __v_29: G = G::from_u64(54);
+    let __v_30: G = G::from_u64(71);
+    let __v_31: G = G::from_u64(177);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_212] = [__v_32];
     record.function_queries[212].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20469,38 +20412,38 @@ fn aiur_fn_213(
   unconstrained: bool,
 ) -> Result<[G; OUT_213], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(63);
-    let __v_1: G = G::from_u64(146);
-    let __v_2: G = G::from_u64(164);
-    let __v_3: G = G::from_u64(106);
-    let __v_4: G = G::from_u64(20);
-    let __v_5: G = G::from_u64(81);
-    let __v_6: G = G::from_u64(253);
-    let __v_7: G = G::from_u64(102);
-    let __v_8: G = G::from_u64(33);
-    let __v_9: G = G::from_u64(90);
-    let __v_10: G = G::from_u64(174);
-    let __v_11: G = G::from_u64(156);
-    let __v_12: G = G::from_u64(247);
-    let __v_13: G = G::from_u64(137);
-    let __v_14: G = G::from_u64(206);
-    let __v_15: G = G::from_u64(56);
-    let __v_16: G = G::from_u64(162);
-    let __v_17: G = G::from_u64(199);
-    let __v_18: G = G::from_u64(63);
-    let __v_19: G = G::from_u64(221);
-    let __v_20: G = G::from_u64(85);
-    let __v_21: G = G::from_u64(144);
-    let __v_22: G = G::from_u64(157);
-    let __v_23: G = G::from_u64(69);
-    let __v_24: G = G::from_u64(79);
-    let __v_25: G = G::from_u64(97);
-    let __v_26: G = G::from_u64(37);
-    let __v_27: G = G::from_u64(150);
-    let __v_28: G = G::from_u64(52);
-    let __v_29: G = G::from_u64(217);
-    let __v_30: G = G::from_u64(11);
-    let __v_31: G = G::from_u64(107);
+    let __v_0: G = G::from_u64(39);
+    let __v_1: G = G::from_u64(46);
+    let __v_2: G = G::from_u64(165);
+    let __v_3: G = G::from_u64(206);
+    let __v_4: G = G::from_u64(107);
+    let __v_5: G = G::from_u64(171);
+    let __v_6: G = G::from_u64(137);
+    let __v_7: G = G::from_u64(88);
+    let __v_8: G = G::from_u64(22);
+    let __v_9: G = G::from_u64(92);
+    let __v_10: G = G::from_u64(127);
+    let __v_11: G = G::from_u64(86);
+    let __v_12: G = G::from_u64(215);
+    let __v_13: G = G::from_u64(31);
+    let __v_14: G = G::from_u64(254);
+    let __v_15: G = G::from_u64(42);
+    let __v_16: G = G::from_u64(91);
+    let __v_17: G = G::from_u64(23);
+    let __v_18: G = G::from_u64(94);
+    let __v_19: G = G::from_u64(213);
+    let __v_20: G = G::from_u64(129);
+    let __v_21: G = G::from_u64(16);
+    let __v_22: G = G::from_u64(18);
+    let __v_23: G = G::from_u64(109);
+    let __v_24: G = G::from_u64(250);
+    let __v_25: G = G::from_u64(150);
+    let __v_26: G = G::from_u64(225);
+    let __v_27: G = G::from_u64(248);
+    let __v_28: G = G::from_u64(160);
+    let __v_29: G = G::from_u64(201);
+    let __v_30: G = G::from_u64(154);
+    let __v_31: G = G::from_u64(210);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_213] = [__v_32];
     record.function_queries[213].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20518,38 +20461,38 @@ fn aiur_fn_214(
   unconstrained: bool,
 ) -> Result<[G; OUT_214], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(162);
-    let __v_1: G = G::from_u64(163);
-    let __v_2: G = G::from_u64(16);
-    let __v_3: G = G::from_u64(19);
-    let __v_4: G = G::from_u64(61);
-    let __v_5: G = G::from_u64(23);
-    let __v_6: G = G::from_u64(55);
-    let __v_7: G = G::from_u64(26);
-    let __v_8: G = G::from_u64(246);
-    let __v_9: G = G::from_u64(124);
-    let __v_10: G = G::from_u64(217);
-    let __v_11: G = G::from_u64(29);
-    let __v_12: G = G::from_u64(39);
-    let __v_13: G = G::from_u64(154);
-    let __v_14: G = G::from_u64(175);
-    let __v_15: G = G::from_u64(115);
-    let __v_16: G = G::from_u64(95);
-    let __v_17: G = G::from_u64(168);
-    let __v_18: G = G::from_u64(203);
-    let __v_19: G = G::from_u64(129);
-    let __v_20: G = G::from_u64(12);
-    let __v_21: G = G::from_u64(57);
-    let __v_22: G = G::from_u64(170);
-    let __v_23: G = G::from_u64(168);
-    let __v_24: G = G::from_u64(36);
-    let __v_25: G = G::from_u64(164);
-    let __v_26: G = G::from_u64(67);
-    let __v_27: G = G::from_u64(198);
-    let __v_28: G = G::from_u64(82);
-    let __v_29: G = G::from_u64(227);
-    let __v_30: G = G::from_u64(223);
-    let __v_31: G = G::from_u64(102);
+    let __v_0: G = G::from_u64(202);
+    let __v_1: G = G::from_u64(245);
+    let __v_2: G = G::from_u64(27);
+    let __v_3: G = G::from_u64(3);
+    let __v_4: G = G::from_u64(157);
+    let __v_5: G = G::from_u64(113);
+    let __v_6: G = G::from_u64(207);
+    let __v_7: G = G::from_u64(206);
+    let __v_8: G = G::from_u64(112);
+    let __v_9: G = G::from_u64(99);
+    let __v_10: G = G::from_u64(225);
+    let __v_11: G = G::from_u64(6);
+    let __v_12: G = G::from_u64(6);
+    let __v_13: G = G::from_u64(79);
+    let __v_14: G = G::from_u64(148);
+    let __v_15: G = G::from_u64(53);
+    let __v_16: G = G::from_u64(245);
+    let __v_17: G = G::from_u64(51);
+    let __v_18: G = G::from_u64(123);
+    let __v_19: G = G::from_u64(188);
+    let __v_20: G = G::from_u64(66);
+    let __v_21: G = G::from_u64(86);
+    let __v_22: G = G::from_u64(124);
+    let __v_23: G = G::from_u64(140);
+    let __v_24: G = G::from_u64(120);
+    let __v_25: G = G::from_u64(181);
+    let __v_26: G = G::from_u64(246);
+    let __v_27: G = G::from_u64(108);
+    let __v_28: G = G::from_u64(127);
+    let __v_29: G = G::from_u64(8);
+    let __v_30: G = G::from_u64(121);
+    let __v_31: G = G::from_u64(32);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_214] = [__v_32];
     record.function_queries[214].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20567,38 +20510,38 @@ fn aiur_fn_215(
   unconstrained: bool,
 ) -> Result<[G; OUT_215], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(173);
-    let __v_1: G = G::from_u64(112);
-    let __v_2: G = G::from_u64(12);
-    let __v_3: G = G::from_u64(8);
-    let __v_4: G = G::from_u64(6);
-    let __v_5: G = G::from_u64(230);
-    let __v_6: G = G::from_u64(115);
-    let __v_7: G = G::from_u64(231);
-    let __v_8: G = G::from_u64(74);
-    let __v_9: G = G::from_u64(220);
-    let __v_10: G = G::from_u64(175);
-    let __v_11: G = G::from_u64(194);
-    let __v_12: G = G::from_u64(140);
-    let __v_13: G = G::from_u64(166);
-    let __v_14: G = G::from_u64(89);
-    let __v_15: G = G::from_u64(211);
-    let __v_16: G = G::from_u64(10);
-    let __v_17: G = G::from_u64(97);
-    let __v_18: G = G::from_u64(102);
-    let __v_19: G = G::from_u64(51);
-    let __v_20: G = G::from_u64(164);
-    let __v_21: G = G::from_u64(163);
-    let __v_22: G = G::from_u64(100);
-    let __v_23: G = G::from_u64(32);
-    let __v_24: G = G::from_u64(50);
-    let __v_25: G = G::from_u64(79);
-    let __v_26: G = G::from_u64(194);
-    let __v_27: G = G::from_u64(158);
-    let __v_28: G = G::from_u64(174);
-    let __v_29: G = G::from_u64(105);
-    let __v_30: G = G::from_u64(235);
-    let __v_31: G = G::from_u64(156);
+    let __v_0: G = G::from_u64(57);
+    let __v_1: G = G::from_u64(148);
+    let __v_2: G = G::from_u64(188);
+    let __v_3: G = G::from_u64(81);
+    let __v_4: G = G::from_u64(227);
+    let __v_5: G = G::from_u64(104);
+    let __v_6: G = G::from_u64(111);
+    let __v_7: G = G::from_u64(48);
+    let __v_8: G = G::from_u64(161);
+    let __v_9: G = G::from_u64(212);
+    let __v_10: G = G::from_u64(131);
+    let __v_11: G = G::from_u64(214);
+    let __v_12: G = G::from_u64(157);
+    let __v_13: G = G::from_u64(10);
+    let __v_14: G = G::from_u64(131);
+    let __v_15: G = G::from_u64(90);
+    let __v_16: G = G::from_u64(123);
+    let __v_17: G = G::from_u64(72);
+    let __v_18: G = G::from_u64(77);
+    let __v_19: G = G::from_u64(137);
+    let __v_20: G = G::from_u64(35);
+    let __v_21: G = G::from_u64(147);
+    let __v_22: G = G::from_u64(192);
+    let __v_23: G = G::from_u64(132);
+    let __v_24: G = G::from_u64(248);
+    let __v_25: G = G::from_u64(122);
+    let __v_26: G = G::from_u64(88);
+    let __v_27: G = G::from_u64(73);
+    let __v_28: G = G::from_u64(222);
+    let __v_29: G = G::from_u64(84);
+    let __v_30: G = G::from_u64(243);
+    let __v_31: G = G::from_u64(2);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_215] = [__v_32];
     record.function_queries[215].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20616,38 +20559,38 @@ fn aiur_fn_216(
   unconstrained: bool,
 ) -> Result<[G; OUT_216], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(216);
-    let __v_1: G = G::from_u64(56);
-    let __v_2: G = G::from_u64(187);
-    let __v_3: G = G::from_u64(107);
-    let __v_4: G = G::from_u64(182);
-    let __v_5: G = G::from_u64(81);
-    let __v_6: G = G::from_u64(83);
-    let __v_7: G = G::from_u64(48);
-    let __v_8: G = G::from_u64(129);
-    let __v_9: G = G::from_u64(172);
-    let __v_10: G = G::from_u64(36);
-    let __v_11: G = G::from_u64(149);
-    let __v_12: G = G::from_u64(162);
-    let __v_13: G = G::from_u64(93);
-    let __v_14: G = G::from_u64(105);
-    let __v_15: G = G::from_u64(12);
-    let __v_16: G = G::from_u64(84);
-    let __v_17: G = G::from_u64(248);
-    let __v_18: G = G::from_u64(227);
-    let __v_19: G = G::from_u64(69);
-    let __v_20: G = G::from_u64(255);
-    let __v_21: G = G::from_u64(244);
-    let __v_22: G = G::from_u64(30);
-    let __v_23: G = G::from_u64(251);
-    let __v_24: G = G::from_u64(213);
-    let __v_25: G = G::from_u64(88);
-    let __v_26: G = G::from_u64(94);
-    let __v_27: G = G::from_u64(180);
-    let __v_28: G = G::from_u64(104);
-    let __v_29: G = G::from_u64(112);
-    let __v_30: G = G::from_u64(83);
-    let __v_31: G = G::from_u64(8);
+    let __v_0: G = G::from_u64(179);
+    let __v_1: G = G::from_u64(167);
+    let __v_2: G = G::from_u64(216);
+    let __v_3: G = G::from_u64(2);
+    let __v_4: G = G::from_u64(73);
+    let __v_5: G = G::from_u64(253);
+    let __v_6: G = G::from_u64(130);
+    let __v_7: G = G::from_u64(49);
+    let __v_8: G = G::from_u64(0);
+    let __v_9: G = G::from_u64(238);
+    let __v_10: G = G::from_u64(3);
+    let __v_11: G = G::from_u64(98);
+    let __v_12: G = G::from_u64(98);
+    let __v_13: G = G::from_u64(50);
+    let __v_14: G = G::from_u64(209);
+    let __v_15: G = G::from_u64(65);
+    let __v_16: G = G::from_u64(42);
+    let __v_17: G = G::from_u64(14);
+    let __v_18: G = G::from_u64(131);
+    let __v_19: G = G::from_u64(53);
+    let __v_20: G = G::from_u64(39);
+    let __v_21: G = G::from_u64(93);
+    let __v_22: G = G::from_u64(93);
+    let __v_23: G = G::from_u64(245);
+    let __v_24: G = G::from_u64(59);
+    let __v_25: G = G::from_u64(146);
+    let __v_26: G = G::from_u64(148);
+    let __v_27: G = G::from_u64(56);
+    let __v_28: G = G::from_u64(135);
+    let __v_29: G = G::from_u64(182);
+    let __v_30: G = G::from_u64(80);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_216] = [__v_32];
     record.function_queries[216].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20665,38 +20608,38 @@ fn aiur_fn_217(
   unconstrained: bool,
 ) -> Result<[G; OUT_217], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(214);
-    let __v_1: G = G::from_u64(22);
-    let __v_2: G = G::from_u64(50);
-    let __v_3: G = G::from_u64(125);
-    let __v_4: G = G::from_u64(79);
-    let __v_5: G = G::from_u64(194);
-    let __v_6: G = G::from_u64(25);
-    let __v_7: G = G::from_u64(189);
-    let __v_8: G = G::from_u64(113);
-    let __v_9: G = G::from_u64(20);
-    let __v_10: G = G::from_u64(186);
-    let __v_11: G = G::from_u64(212);
-    let __v_12: G = G::from_u64(108);
-    let __v_13: G = G::from_u64(208);
-    let __v_14: G = G::from_u64(134);
-    let __v_15: G = G::from_u64(107);
-    let __v_16: G = G::from_u64(239);
-    let __v_17: G = G::from_u64(226);
-    let __v_18: G = G::from_u64(85);
-    let __v_19: G = G::from_u64(21);
-    let __v_20: G = G::from_u64(24);
-    let __v_21: G = G::from_u64(181);
-    let __v_22: G = G::from_u64(191);
-    let __v_23: G = G::from_u64(46);
-    let __v_24: G = G::from_u64(16);
-    let __v_25: G = G::from_u64(181);
-    let __v_26: G = G::from_u64(202);
-    let __v_27: G = G::from_u64(201);
-    let __v_28: G = G::from_u64(51);
-    let __v_29: G = G::from_u64(129);
-    let __v_30: G = G::from_u64(251);
-    let __v_31: G = G::from_u64(119);
+    let __v_0: G = G::from_u64(76);
+    let __v_1: G = G::from_u64(89);
+    let __v_2: G = G::from_u64(188);
+    let __v_3: G = G::from_u64(78);
+    let __v_4: G = G::from_u64(172);
+    let __v_5: G = G::from_u64(130);
+    let __v_6: G = G::from_u64(211);
+    let __v_7: G = G::from_u64(30);
+    let __v_8: G = G::from_u64(190);
+    let __v_9: G = G::from_u64(213);
+    let __v_10: G = G::from_u64(155);
+    let __v_11: G = G::from_u64(178);
+    let __v_12: G = G::from_u64(6);
+    let __v_13: G = G::from_u64(144);
+    let __v_14: G = G::from_u64(157);
+    let __v_15: G = G::from_u64(189);
+    let __v_16: G = G::from_u64(237);
+    let __v_17: G = G::from_u64(101);
+    let __v_18: G = G::from_u64(185);
+    let __v_19: G = G::from_u64(47);
+    let __v_20: G = G::from_u64(213);
+    let __v_21: G = G::from_u64(109);
+    let __v_22: G = G::from_u64(226);
+    let __v_23: G = G::from_u64(81);
+    let __v_24: G = G::from_u64(143);
+    let __v_25: G = G::from_u64(205);
+    let __v_26: G = G::from_u64(173);
+    let __v_27: G = G::from_u64(176);
+    let __v_28: G = G::from_u64(164);
+    let __v_29: G = G::from_u64(44);
+    let __v_30: G = G::from_u64(17);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_217] = [__v_32];
     record.function_queries[217].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20714,38 +20657,38 @@ fn aiur_fn_218(
   unconstrained: bool,
 ) -> Result<[G; OUT_218], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(66);
-    let __v_1: G = G::from_u64(136);
-    let __v_2: G = G::from_u64(249);
-    let __v_3: G = G::from_u64(46);
-    let __v_4: G = G::from_u64(209);
-    let __v_5: G = G::from_u64(213);
-    let __v_6: G = G::from_u64(31);
-    let __v_7: G = G::from_u64(73);
-    let __v_8: G = G::from_u64(53);
-    let __v_9: G = G::from_u64(229);
-    let __v_10: G = G::from_u64(210);
-    let __v_11: G = G::from_u64(119);
-    let __v_12: G = G::from_u64(95);
-    let __v_13: G = G::from_u64(51);
-    let __v_14: G = G::from_u64(236);
-    let __v_15: G = G::from_u64(88);
-    let __v_16: G = G::from_u64(93);
-    let __v_17: G = G::from_u64(111);
-    let __v_18: G = G::from_u64(229);
-    let __v_19: G = G::from_u64(236);
-    let __v_20: G = G::from_u64(99);
-    let __v_21: G = G::from_u64(218);
-    let __v_22: G = G::from_u64(223);
-    let __v_23: G = G::from_u64(14);
-    let __v_24: G = G::from_u64(166);
-    let __v_25: G = G::from_u64(152);
-    let __v_26: G = G::from_u64(85);
-    let __v_27: G = G::from_u64(68);
-    let __v_28: G = G::from_u64(120);
-    let __v_29: G = G::from_u64(253);
-    let __v_30: G = G::from_u64(159);
-    let __v_31: G = G::from_u64(173);
+    let __v_0: G = G::from_u64(50);
+    let __v_1: G = G::from_u64(16);
+    let __v_2: G = G::from_u64(75);
+    let __v_3: G = G::from_u64(3);
+    let __v_4: G = G::from_u64(52);
+    let __v_5: G = G::from_u64(141);
+    let __v_6: G = G::from_u64(17);
+    let __v_7: G = G::from_u64(172);
+    let __v_8: G = G::from_u64(178);
+    let __v_9: G = G::from_u64(67);
+    let __v_10: G = G::from_u64(127);
+    let __v_11: G = G::from_u64(218);
+    let __v_12: G = G::from_u64(36);
+    let __v_13: G = G::from_u64(150);
+    let __v_14: G = G::from_u64(109);
+    let __v_15: G = G::from_u64(197);
+    let __v_16: G = G::from_u64(140);
+    let __v_17: G = G::from_u64(200);
+    let __v_18: G = G::from_u64(200);
+    let __v_19: G = G::from_u64(188);
+    let __v_20: G = G::from_u64(202);
+    let __v_21: G = G::from_u64(150);
+    let __v_22: G = G::from_u64(88);
+    let __v_23: G = G::from_u64(38);
+    let __v_24: G = G::from_u64(20);
+    let __v_25: G = G::from_u64(230);
+    let __v_26: G = G::from_u64(68);
+    let __v_27: G = G::from_u64(211);
+    let __v_28: G = G::from_u64(25);
+    let __v_29: G = G::from_u64(164);
+    let __v_30: G = G::from_u64(44);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __ret: [G; OUT_218] = [__v_32];
     record.function_queries[218].finish(&inp[..], &__ret[..], !unconstrained);
@@ -20753,8 +20696,8 @@ fn aiur_fn_218(
   })
 }
 
-const INPUT_SIZE_219: usize = 1;
-const IN_219: usize = 1;
+const INPUT_SIZE_219: usize = 0;
+const IN_219: usize = 0;
 const OUT_219: usize = 1;
 fn aiur_fn_219(
   inp: [G; IN_219],
@@ -20762,95 +20705,340 @@ fn aiur_fn_219(
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
 ) -> Result<[G; OUT_219], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(55);
+    let __v_1: G = G::from_u64(239);
+    let __v_2: G = G::from_u64(95);
+    let __v_3: G = G::from_u64(238);
+    let __v_4: G = G::from_u64(118);
+    let __v_5: G = G::from_u64(93);
+    let __v_6: G = G::from_u64(194);
+    let __v_7: G = G::from_u64(229);
+    let __v_8: G = G::from_u64(199);
+    let __v_9: G = G::from_u64(66);
+    let __v_10: G = G::from_u64(92);
+    let __v_11: G = G::from_u64(24);
+    let __v_12: G = G::from_u64(12);
+    let __v_13: G = G::from_u64(212);
+    let __v_14: G = G::from_u64(32);
+    let __v_15: G = G::from_u64(7);
+    let __v_16: G = G::from_u64(219);
+    let __v_17: G = G::from_u64(125);
+    let __v_18: G = G::from_u64(41);
+    let __v_19: G = G::from_u64(174);
+    let __v_20: G = G::from_u64(13);
+    let __v_21: G = G::from_u64(92);
+    let __v_22: G = G::from_u64(9);
+    let __v_23: G = G::from_u64(23);
+    let __v_24: G = G::from_u64(137);
+    let __v_25: G = G::from_u64(244);
+    let __v_26: G = G::from_u64(98);
+    let __v_27: G = G::from_u64(242);
+    let __v_28: G = G::from_u64(128);
+    let __v_29: G = G::from_u64(91);
+    let __v_30: G = G::from_u64(14);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_219] = [__v_32];
+    record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_220: usize = 0;
+const IN_220: usize = 0;
+const OUT_220: usize = 1;
+fn aiur_fn_220(
+  inp: [G; IN_220],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_220], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(121);
+    let __v_1: G = G::from_u64(134);
+    let __v_2: G = G::from_u64(42);
+    let __v_3: G = G::from_u64(207);
+    let __v_4: G = G::from_u64(188);
+    let __v_5: G = G::from_u64(46);
+    let __v_6: G = G::from_u64(55);
+    let __v_7: G = G::from_u64(183);
+    let __v_8: G = G::from_u64(182);
+    let __v_9: G = G::from_u64(18);
+    let __v_10: G = G::from_u64(33);
+    let __v_11: G = G::from_u64(67);
+    let __v_12: G = G::from_u64(240);
+    let __v_13: G = G::from_u64(166);
+    let __v_14: G = G::from_u64(165);
+    let __v_15: G = G::from_u64(17);
+    let __v_16: G = G::from_u64(20);
+    let __v_17: G = G::from_u64(195);
+    let __v_18: G = G::from_u64(79);
+    let __v_19: G = G::from_u64(164);
+    let __v_20: G = G::from_u64(131);
+    let __v_21: G = G::from_u64(255);
+    let __v_22: G = G::from_u64(20);
+    let __v_23: G = G::from_u64(20);
+    let __v_24: G = G::from_u64(100);
+    let __v_25: G = G::from_u64(131);
+    let __v_26: G = G::from_u64(222);
+    let __v_27: G = G::from_u64(24);
+    let __v_28: G = G::from_u64(131);
+    let __v_29: G = G::from_u64(93);
+    let __v_30: G = G::from_u64(66);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_220] = [__v_32];
+    record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_221: usize = 0;
+const IN_221: usize = 0;
+const OUT_221: usize = 1;
+fn aiur_fn_221(
+  inp: [G; IN_221],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_221], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(191);
+    let __v_1: G = G::from_u64(88);
+    let __v_2: G = G::from_u64(230);
+    let __v_3: G = G::from_u64(203);
+    let __v_4: G = G::from_u64(58);
+    let __v_5: G = G::from_u64(160);
+    let __v_6: G = G::from_u64(247);
+    let __v_7: G = G::from_u64(70);
+    let __v_8: G = G::from_u64(133);
+    let __v_9: G = G::from_u64(6);
+    let __v_10: G = G::from_u64(41);
+    let __v_11: G = G::from_u64(4);
+    let __v_12: G = G::from_u64(22);
+    let __v_13: G = G::from_u64(53);
+    let __v_14: G = G::from_u64(205);
+    let __v_15: G = G::from_u64(48);
+    let __v_16: G = G::from_u64(192);
+    let __v_17: G = G::from_u64(173);
+    let __v_18: G = G::from_u64(102);
+    let __v_19: G = G::from_u64(38);
+    let __v_20: G = G::from_u64(43);
+    let __v_21: G = G::from_u64(102);
+    let __v_22: G = G::from_u64(23);
+    let __v_23: G = G::from_u64(102);
+    let __v_24: G = G::from_u64(15);
+    let __v_25: G = G::from_u64(34);
+    let __v_26: G = G::from_u64(144);
+    let __v_27: G = G::from_u64(36);
+    let __v_28: G = G::from_u64(31);
+    let __v_29: G = G::from_u64(8);
+    let __v_30: G = G::from_u64(176);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_221] = [__v_32];
+    record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_222: usize = 0;
+const IN_222: usize = 0;
+const OUT_222: usize = 1;
+fn aiur_fn_222(
+  inp: [G; IN_222],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_222], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(25);
+    let __v_1: G = G::from_u64(19);
+    let __v_2: G = G::from_u64(79);
+    let __v_3: G = G::from_u64(220);
+    let __v_4: G = G::from_u64(24);
+    let __v_5: G = G::from_u64(142);
+    let __v_6: G = G::from_u64(131);
+    let __v_7: G = G::from_u64(119);
+    let __v_8: G = G::from_u64(208);
+    let __v_9: G = G::from_u64(23);
+    let __v_10: G = G::from_u64(56);
+    let __v_11: G = G::from_u64(87);
+    let __v_12: G = G::from_u64(225);
+    let __v_13: G = G::from_u64(93);
+    let __v_14: G = G::from_u64(59);
+    let __v_15: G = G::from_u64(80);
+    let __v_16: G = G::from_u64(101);
+    let __v_17: G = G::from_u64(237);
+    let __v_18: G = G::from_u64(118);
+    let __v_19: G = G::from_u64(218);
+    let __v_20: G = G::from_u64(152);
+    let __v_21: G = G::from_u64(19);
+    let __v_22: G = G::from_u64(151);
+    let __v_23: G = G::from_u64(16);
+    let __v_24: G = G::from_u64(126);
+    let __v_25: G = G::from_u64(92);
+    let __v_26: G = G::from_u64(64);
+    let __v_27: G = G::from_u64(77);
+    let __v_28: G = G::from_u64(179);
+    let __v_29: G = G::from_u64(243);
+    let __v_30: G = G::from_u64(183);
+    let __v_31: G = G::from_u64(24);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_222] = [__v_32];
+    record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_223: usize = 0;
+const IN_223: usize = 0;
+const OUT_223: usize = 1;
+fn aiur_fn_223(
+  inp: [G; IN_223],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_223], ExecError> {
+  stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
+    let __v_0: G = G::from_u64(157);
+    let __v_1: G = G::from_u64(106);
+    let __v_2: G = G::from_u64(228);
+    let __v_3: G = G::from_u64(52);
+    let __v_4: G = G::from_u64(41);
+    let __v_5: G = G::from_u64(236);
+    let __v_6: G = G::from_u64(2);
+    let __v_7: G = G::from_u64(169);
+    let __v_8: G = G::from_u64(51);
+    let __v_9: G = G::from_u64(139);
+    let __v_10: G = G::from_u64(188);
+    let __v_11: G = G::from_u64(208);
+    let __v_12: G = G::from_u64(219);
+    let __v_13: G = G::from_u64(10);
+    let __v_14: G = G::from_u64(193);
+    let __v_15: G = G::from_u64(147);
+    let __v_16: G = G::from_u64(215);
+    let __v_17: G = G::from_u64(94);
+    let __v_18: G = G::from_u64(189);
+    let __v_19: G = G::from_u64(70);
+    let __v_20: G = G::from_u64(248);
+    let __v_21: G = G::from_u64(132);
+    let __v_22: G = G::from_u64(191);
+    let __v_23: G = G::from_u64(203);
+    let __v_24: G = G::from_u64(210);
+    let __v_25: G = G::from_u64(196);
+    let __v_26: G = G::from_u64(43);
+    let __v_27: G = G::from_u64(247);
+    let __v_28: G = G::from_u64(250);
+    let __v_29: G = G::from_u64(234);
+    let __v_30: G = G::from_u64(21);
+    let __v_31: G = G::from_u64(13);
+    let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
+    let __ret: [G; OUT_223] = [__v_32];
+    record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained);
+    return Ok(__ret);
+  })
+}
+
+const INPUT_SIZE_224: usize = 1;
+const IN_224: usize = 1;
+const OUT_224: usize = 1;
+fn aiur_fn_224(
+  inp: [G; IN_224],
+  record: &mut QueryRecord,
+  io_buffer: &mut IOBuffer,
+  unconstrained: bool,
+) -> Result<[G; OUT_224], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_219] = [__v_3];
-        record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_224] = [__v_3];
+        record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; let __hit = record.function_queries[212].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => aiur_fn_212(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_219] = [__v_5];
-            record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_224] = [__v_5];
+            record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_219] = [__v_7];
-                record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_224] = [__v_7];
+                record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_219] = [__v_9];
-                    record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_224] = [__v_9];
+                    record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_219] = [__v_11];
-                        record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_224] = [__v_11];
+                        record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_12: G = __r_arr[0];
                         match __v_12.as_canonical_u64() {
                           1u64 => {
                             let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_219] = [__v_13];
-                            record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_224] = [__v_13];
+                            record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = []; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } };
                             let __v_13: G = __r_arr[0];
                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(1);
-                                let __ret: [G; OUT_219] = [__v_15];
-                                record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_224] = [__v_15];
+                                record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_15: G = G::from_u64(0);
-                                let __ret: [G; OUT_219] = [__v_15];
-                                record.function_queries[219].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_224] = [__v_15];
+                                record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -20869,22 +21057,22 @@ fn aiur_fn_219(
   })
 }
 
-const INPUT_SIZE_220: usize = 3;
-const IN_220: usize = 3;
-const OUT_220: usize = 2;
-fn aiur_fn_220(
-  inp: [G; IN_220],
+const INPUT_SIZE_225: usize = 3;
+const IN_225: usize = 3;
+const OUT_225: usize = 2;
+fn aiur_fn_225(
+  inp: [G; IN_225],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_220], ExecError> {
+) -> Result<[G; OUT_225], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -20893,9 +21081,9 @@ fn aiur_fn_220(
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             match __v_8.as_canonical_u64() {
@@ -20905,8 +21093,8 @@ fn aiur_fn_220(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_220] = [__v_10, __v_14];
-                record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_225] = [__v_10, __v_14];
+                record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
@@ -20915,8 +21103,8 @@ fn aiur_fn_220(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_220] = [__v_10, __v_14];
-                record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_225] = [__v_10, __v_14];
+                record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -20930,14 +21118,14 @@ fn aiur_fn_220(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_220] = [__v_6, __v_10];
-            record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_225] = [__v_6, __v_10];
+            record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = []; let __cu = unconstrained; let __hit = record.function_queries[206].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[206].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[206].bump_multiplicity(__i); } let __ret: [G; OUT_206] = unsafe { *(record.function_queries[206].output_at(__i).as_ptr() as *const [G; OUT_206]) }; __ret }, _ => aiur_fn_206(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
@@ -20952,13 +21140,13 @@ fn aiur_fn_220(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_220] = [__v_10, __v_14];
-                record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_225] = [__v_10, __v_14];
+                record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_12: G = __loaded[0];
@@ -20969,17 +21157,17 @@ fn aiur_fn_220(
                   7u64 => {
                     match __v_13.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                         let __v_16: G = __r_arr[0];
-                        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__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(7);
                         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_17, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_220] = [__v_18, __v_22];
-                        record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_225] = [__v_18, __v_22];
+                        record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -20988,8 +21176,8 @@ fn aiur_fn_220(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_220] = [__v_16, __v_20];
-                        record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_225] = [__v_16, __v_20];
+                        record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -21000,8 +21188,8 @@ fn aiur_fn_220(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_220] = [__v_16, __v_20];
-                    record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_225] = [__v_16, __v_20];
+                    record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -21009,63 +21197,63 @@ fn aiur_fn_220(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = __r_arr[1];
-                let __ret: [G; OUT_220] = [__v_10, __v_11];
-                record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_225] = [__v_10, __v_11];
+                record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = []; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     let __v_13: G = __r_arr[1];
-                    let __ret: [G; OUT_220] = [__v_12, __v_13];
-                    record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_225] = [__v_12, __v_13];
+                    record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = []; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
                     match __v_13.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         let __v_15: G = __r_arr[1];
-                        let __ret: [G; OUT_220] = [__v_14, __v_15];
-                        record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_225] = [__v_14, __v_15];
+                        record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = []; let __cu = unconstrained; let __hit = record.function_queries[222].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[222].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[222].bump_multiplicity(__i); } let __ret: [G; OUT_222] = unsafe { *(record.function_queries[222].output_at(__i).as_ptr() as *const [G; OUT_222]) }; __ret }, _ => aiur_fn_222(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
                         match __v_15.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
                             let __v_17: G = __r_arr[1];
-                            let __ret: [G; OUT_220] = [__v_16, __v_17];
-                            record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_225] = [__v_16, __v_17];
+                            record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = []; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; let __hit = record.function_queries[212].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => aiur_fn_212(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_17: G = __r_arr[0];
@@ -21080,16 +21268,16 @@ fn aiur_fn_220(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_220] = [__v_20, __v_24];
-                                    record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_225] = [__v_20, __v_24];
+                                    record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
                                     let __v_20: G = G::from_u64(0);
-                                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                                     let __v_21: G = __r_arr[0];
                                     let __v_22: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                                     let __v_24: G = __loaded[0];
@@ -21109,15 +21297,15 @@ fn aiur_fn_220(
                                               7u64 => {
                                                 match __v_29.as_canonical_u64() {
                                                   1u64 => {
-                                                    let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_26, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_26, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_220] = [__v_33, __v_37];
-                                                    record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                                    let __ret: [G; OUT_225] = [__v_33, __v_37];
+                                                    record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -21126,8 +21314,8 @@ fn aiur_fn_220(
                                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_220] = [__v_32, __v_36];
-                                                    record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                                    let __ret: [G; OUT_225] = [__v_32, __v_36];
+                                                    record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -21138,8 +21326,8 @@ fn aiur_fn_220(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_220] = [__v_32, __v_36];
-                                                record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_225] = [__v_32, __v_36];
+                                                record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -21150,8 +21338,8 @@ fn aiur_fn_220(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_220] = [__v_28, __v_32];
-                                            record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_225] = [__v_28, __v_32];
+                                            record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -21162,8 +21350,8 @@ fn aiur_fn_220(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_220] = [__v_28, __v_32];
-                                        record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_225] = [__v_28, __v_32];
+                                        record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                     }
@@ -21176,8 +21364,8 @@ fn aiur_fn_220(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_220] = [__v_18, __v_22];
-                                record.function_queries[220].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_225] = [__v_18, __v_22];
+                                record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -21196,18 +21384,18 @@ fn aiur_fn_220(
   })
 }
 
-const INPUT_SIZE_221: usize = 1;
-const IN_221: usize = 1;
-const OUT_221: usize = 2;
-fn aiur_fn_221(
-  inp: [G; IN_221],
+const INPUT_SIZE_226: usize = 1;
+const IN_226: usize = 1;
+const OUT_226: usize = 2;
+fn aiur_fn_226(
+  inp: [G; IN_226],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_221], ExecError> {
+) -> Result<[G; OUT_226], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -21218,13 +21406,13 @@ fn aiur_fn_221(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_221] = [__v_4, __v_8];
-        record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_226] = [__v_4, __v_8];
+        record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
@@ -21235,16 +21423,16 @@ fn aiur_fn_221(
           7u64 => {
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __v_12: G = G::from_u64(7);
                 let __v_13: G = G::from_u64(0);
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_16: G = G::from_u64(2);
-                let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__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);
@@ -21255,8 +21443,8 @@ fn aiur_fn_221(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_221] = [__v_23, __v_26];
-                record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_226] = [__v_23, __v_26];
+                record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -21265,8 +21453,8 @@ fn aiur_fn_221(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_221] = [__v_10, __v_14];
-                record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_226] = [__v_10, __v_14];
+                record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -21277,8 +21465,8 @@ fn aiur_fn_221(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_221] = [__v_10, __v_14];
-            record.function_queries[221].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_226] = [__v_10, __v_14];
+            record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -21287,18 +21475,18 @@ fn aiur_fn_221(
   })
 }
 
-const INPUT_SIZE_222: usize = 1;
-const IN_222: usize = 1;
-const OUT_222: usize = 2;
-fn aiur_fn_222(
-  inp: [G; IN_222],
+const INPUT_SIZE_227: usize = 1;
+const IN_227: usize = 1;
+const OUT_227: usize = 2;
+fn aiur_fn_227(
+  inp: [G; IN_227],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_222], ExecError> {
+) -> Result<[G; OUT_227], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -21309,13 +21497,13 @@ fn aiur_fn_222(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_222] = [__v_4, __v_8];
-        record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_227] = [__v_4, __v_8];
+        record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
@@ -21334,15 +21522,15 @@ fn aiur_fn_222(
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
                     let __v_14: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = []; let __cu = unconstrained; let __hit = record.function_queries[221].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[221].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[221].bump_multiplicity(__i); } let __ret: [G; OUT_221] = unsafe { *(record.function_queries[221].output_at(__i).as_ptr() as *const [G; OUT_221]) }; __ret }, _ => aiur_fn_221(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_222] = [__v_13, __v_20];
-                    record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_227] = [__v_13, __v_20];
+                    record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -21351,8 +21539,8 @@ fn aiur_fn_222(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_222] = [__v_13, __v_17];
-                    record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_227] = [__v_13, __v_17];
+                    record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -21363,8 +21551,8 @@ fn aiur_fn_222(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_222] = [__v_10, __v_14];
-                record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_227] = [__v_10, __v_14];
+                record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -21375,8 +21563,8 @@ fn aiur_fn_222(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_222] = [__v_10, __v_14];
-            record.function_queries[222].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_227] = [__v_10, __v_14];
+            record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -21385,15 +21573,15 @@ fn aiur_fn_222(
   })
 }
 
-const INPUT_SIZE_223: usize = 1;
-const IN_223: usize = 1;
-const OUT_223: usize = 0;
-fn aiur_fn_223(
-  inp: [G; IN_223],
+const INPUT_SIZE_228: usize = 1;
+const IN_228: usize = 1;
+const OUT_228: usize = 0;
+fn aiur_fn_228(
+  inp: [G; IN_228],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_223], ExecError> {
+) -> Result<[G; OUT_228], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -21402,17 +21590,17 @@ fn aiur_fn_223(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_223] = [];
-        record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_228] = [];
+        record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_223] = [];
-        record.function_queries[223].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_228] = [];
+        record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -21422,35 +21610,35 @@ fn aiur_fn_223(
   })
 }
 
-const INPUT_SIZE_224: usize = 1;
-const IN_224: usize = 1;
-const OUT_224: usize = 1;
-fn aiur_fn_224(
-  inp: [G; IN_224],
+const INPUT_SIZE_229: usize = 1;
+const IN_229: usize = 1;
+const OUT_229: usize = 1;
+fn aiur_fn_229(
+  inp: [G; IN_229],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_224], ExecError> {
+) -> Result<[G; OUT_229], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(65);
-    let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __ret: [G; OUT_224] = [__v_2];
-    record.function_queries[224].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_229] = [__v_2];
+    record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_225: usize = 2;
-const IN_225: usize = 2;
-const OUT_225: usize = 1;
-fn aiur_fn_225(
-  inp: [G; IN_225],
+const INPUT_SIZE_230: usize = 2;
+const IN_230: usize = 2;
+const OUT_230: usize = 1;
+fn aiur_fn_230(
+  inp: [G; IN_230],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_225], ExecError> {
+) -> Result<[G; OUT_230], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21460,18 +21648,18 @@ fn aiur_fn_225(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_225] = [__v_1];
-        record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_230] = [__v_1];
+        record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_225] = [__v_7];
-        record.function_queries[225].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_230] = [__v_7];
+        record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -21481,15 +21669,15 @@ fn aiur_fn_225(
   })
 }
 
-const INPUT_SIZE_226: usize = 1;
-const IN_226: usize = 1;
-const OUT_226: usize = 1;
-fn aiur_fn_226(
-  inp: [G; IN_226],
+const INPUT_SIZE_231: usize = 1;
+const IN_231: usize = 1;
+const OUT_231: usize = 1;
+fn aiur_fn_231(
+  inp: [G; IN_231],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_226], ExecError> {
+) -> Result<[G; OUT_231], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(128);
@@ -21502,8 +21690,8 @@ fn aiur_fn_226(
           1u64 => {
             let __v_5: G = G::from_u64(128);
             let __v_6: G = (__v_0 - __v_5);
-            let __ret: [G; OUT_226] = [__v_6];
-            record.function_queries[226].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_231] = [__v_6];
+            record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -21518,15 +21706,15 @@ fn aiur_fn_226(
   })
 }
 
-const INPUT_SIZE_227: usize = 2;
-const IN_227: usize = 2;
-const OUT_227: usize = 2;
-fn aiur_fn_227(
-  inp: [G; IN_227],
+const INPUT_SIZE_232: usize = 2;
+const IN_232: usize = 2;
+const OUT_232: usize = 2;
+fn aiur_fn_232(
+  inp: [G; IN_232],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_227], ExecError> {
+) -> Result<[G; OUT_232], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21534,8 +21722,8 @@ fn aiur_fn_227(
     let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) };
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_227] = [__v_0, __v_1];
-        record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_232] = [__v_0, __v_1];
+        record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -21557,11 +21745,11 @@ fn aiur_fn_227(
                     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_226] = { let __args: [G; IN_226] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
                     let __v_16: G = (__v_14 + __v_15);
-                    let __ret: [G; OUT_227] = [__v_16, __v_10];
-                    record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_232] = [__v_16, __v_10];
+                    record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -21590,11 +21778,11 @@ fn aiur_fn_227(
                             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_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__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_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__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);
@@ -21602,8 +21790,8 @@ fn aiur_fn_227(
                             let __v_27: G = { let __a_val = __v_25.as_canonical_u64(); let __b_val = __v_26.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                             match __v_27.as_canonical_u64() {
                               0u64 => {
-                                let __ret: [G; OUT_227] = [__v_25, __v_15];
-                                record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_232] = [__v_25, __v_15];
+                                record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -21644,15 +21832,15 @@ fn aiur_fn_227(
                                 let __v_20: G = (__v_0 - __v_19);
                                 let __v_21: G = G::from_u64(262144);
                                 let __v_22: G = (__v_20 * __v_21);
-                                let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } };
                                 let __v_23: G = __r_arr[0];
                                 let __v_24: G = G::from_u64(4096);
                                 let __v_25: G = (__v_23 * __v_24);
-                                let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__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_226] = { let __args: [G; IN_226] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[226].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[226].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[226].bump_multiplicity(__i); } let __ret: [G; OUT_226] = unsafe { *(record.function_queries[226].output_at(__i).as_ptr() as *const [G; OUT_226]) }; __ret }, _ => aiur_fn_226(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__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);
@@ -21661,8 +21849,8 @@ fn aiur_fn_227(
                                 let __v_34: G = { let __a_val = __v_32.as_canonical_u64(); let __b_val = __v_33.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                                 match __v_34.as_canonical_u64() {
                                   0u64 => {
-                                    let __ret: [G; OUT_227] = [__v_32, __v_18];
-                                    record.function_queries[227].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_232] = [__v_32, __v_18];
+                                    record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -21698,15 +21886,15 @@ fn aiur_fn_227(
   })
 }
 
-const INPUT_SIZE_228: usize = 1;
-const IN_228: usize = 1;
-const OUT_228: usize = 1;
-fn aiur_fn_228(
-  inp: [G; IN_228],
+const INPUT_SIZE_233: usize = 1;
+const IN_233: usize = 1;
+const OUT_233: usize = 1;
+fn aiur_fn_233(
+  inp: [G; IN_233],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_228], ExecError> {
+) -> Result<[G; OUT_233], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -21718,17 +21906,17 @@ fn aiur_fn_228(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_9: G = G::from_u64(2);
-    let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = G::from_u64(0);
     let __v_12: G = { let __values: [G; 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_13: G = G::from_u64(2);
-    let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_17: G = G::from_u64(2);
-    let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = []; let __cu = unconstrained; let __hit = record.function_queries[212].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[212].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[212].bump_multiplicity(__i); } let __ret: [G; OUT_212] = unsafe { *(record.function_queries[212].output_at(__i).as_ptr() as *const [G; OUT_212]) }; __ret }, _ => aiur_fn_212(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = []; let __cu = unconstrained; let __hit = record.function_queries[217].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[217].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[217].bump_multiplicity(__i); } let __ret: [G; OUT_217] = unsafe { *(record.function_queries[217].output_at(__i).as_ptr() as *const [G; OUT_217]) }; __ret }, _ => aiur_fn_217(__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);
@@ -21736,7 +21924,7 @@ fn aiur_fn_228(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_24: G = G::from_u64(2);
-    let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__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);
@@ -21744,7 +21932,7 @@ fn aiur_fn_228(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_208] = { let __args: [G; IN_208] = []; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = []; let __cu = unconstrained; let __hit = record.function_queries[213].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[213].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[213].bump_multiplicity(__i); } let __ret: [G; OUT_213] = unsafe { *(record.function_queries[213].output_at(__i).as_ptr() as *const [G; OUT_213]) }; __ret }, _ => aiur_fn_213(__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);
@@ -21757,26 +21945,26 @@ fn aiur_fn_228(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_40, __v_43, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_228] = [__v_47];
-    record.function_queries[228].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_233] = [__v_47];
+    record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_229: usize = 4;
-const IN_229: usize = 4;
-const OUT_229: usize = 1;
-fn aiur_fn_229(
-  inp: [G; IN_229],
+const INPUT_SIZE_234: usize = 4;
+const IN_234: usize = 4;
+const OUT_234: usize = 1;
+fn aiur_fn_234(
+  inp: [G; IN_234],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_229], ExecError> {
+) -> Result<[G; OUT_234], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21788,15 +21976,15 @@ fn aiur_fn_229(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_229] = [__v_1];
-        record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_234] = [__v_1];
+        record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[227].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[227].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[227].bump_multiplicity(__i); } let __ret: [G; OUT_227] = unsafe { *(record.function_queries[227].output_at(__i).as_ptr() as *const [G; OUT_227]) }; __ret }, _ => aiur_fn_227(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[232].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[232].bump_multiplicity(__i); } let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(7);
         let __v_11: G = G::from_u64(0);
@@ -21808,13 +21996,13 @@ fn aiur_fn_229(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[229].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[229].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[229].bump_multiplicity(__i); } let __ret: [G; OUT_229] = unsafe { *(record.function_queries[229].output_at(__i).as_ptr() as *const [G; OUT_229]) }; __ret }, _ => aiur_fn_229(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_229] = [__v_23];
-        record.function_queries[229].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_234] = [__v_23];
+        record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -21824,15 +22012,15 @@ fn aiur_fn_229(
   })
 }
 
-const INPUT_SIZE_230: usize = 2;
-const IN_230: usize = 2;
-const OUT_230: usize = 1;
-fn aiur_fn_230(
-  inp: [G; IN_230],
+const INPUT_SIZE_235: usize = 2;
+const IN_235: usize = 2;
+const OUT_235: usize = 1;
+fn aiur_fn_235(
+  inp: [G; IN_235],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_230], ExecError> {
+) -> Result<[G; OUT_235], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21850,7 +22038,7 @@ fn aiur_fn_230(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
@@ -21870,7 +22058,7 @@ fn aiur_fn_230(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_14, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_14, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_27: G = __loaded[0];
@@ -21880,58 +22068,58 @@ fn aiur_fn_230(
                 match __v_27.as_canonical_u64() {
                   4u64 => {
                     let __v_31: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_29, __v_4, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
                     let __v_32: G = __r_arr[0];
-                    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_32, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_32, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
                     let __v_33: G = __r_arr[0];
-                    let __ret: [G; OUT_230] = [__v_33];
-                    record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_235] = [__v_33];
+                    record.function_queries[235].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_33, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_33, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
                     let __v_34: G = __r_arr[0];
-                    let __ret: [G; OUT_230] = [__v_34];
-                    record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_235] = [__v_34];
+                    record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_230] = [__v_0];
-                record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_235] = [__v_0];
+                record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_230] = [__v_0];
-            record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_235] = [__v_0];
+            record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_230] = [__v_0];
-        record.function_queries[230].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_235] = [__v_0];
+        record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_231: usize = 2;
-const IN_231: usize = 2;
-const OUT_231: usize = 1;
-fn aiur_fn_231(
-  inp: [G; IN_231],
+const INPUT_SIZE_236: usize = 2;
+const IN_236: usize = 2;
+const OUT_236: usize = 1;
+fn aiur_fn_236(
+  inp: [G; IN_236],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_231], ExecError> {
+) -> Result<[G; OUT_236], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -21944,75 +22132,75 @@ fn aiur_fn_231(
       7u64 => {
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_231] = [__v_7];
-            record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_236] = [__v_7];
+            record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_231] = [__v_0];
-            record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_236] = [__v_0];
+            record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_231] = [__v_0];
-        record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_236] = [__v_0];
+        record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_232: usize = 1;
-const IN_232: usize = 1;
-const OUT_232: usize = 4;
-fn aiur_fn_232(
-  inp: [G; IN_232],
+const INPUT_SIZE_237: usize = 1;
+const IN_237: usize = 1;
+const OUT_237: usize = 4;
+fn aiur_fn_237(
+  inp: [G; IN_237],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_232], ExecError> {
+) -> Result<[G; OUT_237], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     let __v_10: G = G::from_u64(0);
-    let __r_arr: [G; OUT_126] = { let __args: [G; IN_126] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[126].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[126].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[126].bump_multiplicity(__i); } let __ret: [G; OUT_126] = unsafe { *(record.function_queries[126].output_at(__i).as_ptr() as *const [G; OUT_126]) }; __ret }, _ => aiur_fn_126(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[131].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[131].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[131].bump_multiplicity(__i); } let __ret: [G; OUT_131] = unsafe { *(record.function_queries[131].output_at(__i).as_ptr() as *const [G; OUT_131]) }; __ret }, _ => aiur_fn_131(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = __r_arr[1];
-    let __ret: [G; OUT_232] = [__v_2, __v_5, __v_8, __v_11];
-    record.function_queries[232].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_237] = [__v_2, __v_5, __v_8, __v_11];
+    record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_233: usize = 1;
-const IN_233: usize = 1;
-const OUT_233: usize = 1;
-fn aiur_fn_233(
-  inp: [G; IN_233],
+const INPUT_SIZE_238: usize = 1;
+const IN_238: usize = 1;
+const OUT_238: usize = 1;
+fn aiur_fn_238(
+  inp: [G; IN_238],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_233], ExecError> {
+) -> Result<[G; OUT_238], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_0]; let __cu = true; let __hit = record.function_queries[232].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_232] = unsafe { *(record.function_queries[232].output_at(__i).as_ptr() as *const [G; OUT_232]) }; __ret }, _ => aiur_fn_232(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_0]; let __cu = true; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -22046,29 +22234,29 @@ fn aiur_fn_233(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_31: G = __r_arr[0];
-    let __ret: [G; OUT_233] = [__v_31];
-    record.function_queries[233].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_238] = [__v_31];
+    record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_234: usize = 2;
-const IN_234: usize = 2;
-const OUT_234: usize = 2;
-fn aiur_fn_234(
-  inp: [G; IN_234],
+const INPUT_SIZE_239: usize = 2;
+const IN_239: usize = 2;
+const OUT_239: usize = 2;
+fn aiur_fn_239(
+  inp: [G; IN_239],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_234], ExecError> {
+) -> Result<[G; OUT_239], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -22078,13 +22266,13 @@ fn aiur_fn_234(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = []; let __cu = unconstrained; let __hit = record.function_queries[210].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[210].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[210].bump_multiplicity(__i); } let __ret: [G; OUT_210] = unsafe { *(record.function_queries[210].output_at(__i).as_ptr() as *const [G; OUT_210]) }; __ret }, _ => aiur_fn_210(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = []; let __cu = unconstrained; let __hit = record.function_queries[215].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[215].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[215].bump_multiplicity(__i); } let __ret: [G; OUT_215] = unsafe { *(record.function_queries[215].output_at(__i).as_ptr() as *const [G; OUT_215]) }; __ret }, _ => aiur_fn_215(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
@@ -22092,8 +22280,8 @@ fn aiur_fn_234(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_234] = [__v_12, __v_15];
-                record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_239] = [__v_12, __v_15];
+                record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -22101,14 +22289,14 @@ fn aiur_fn_234(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_234] = [__v_12, __v_15];
-                record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_239] = [__v_12, __v_15];
+                record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = []; let __cu = unconstrained; let __hit = record.function_queries[211].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[211].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[211].bump_multiplicity(__i); } let __ret: [G; OUT_211] = unsafe { *(record.function_queries[211].output_at(__i).as_ptr() as *const [G; OUT_211]) }; __ret }, _ => aiur_fn_211(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = []; let __cu = unconstrained; let __hit = record.function_queries[216].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[216].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[216].bump_multiplicity(__i); } let __ret: [G; OUT_216] = unsafe { *(record.function_queries[216].output_at(__i).as_ptr() as *const [G; OUT_216]) }; __ret }, _ => aiur_fn_216(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
@@ -22118,19 +22306,19 @@ fn aiur_fn_234(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_234] = [__v_13, __v_16];
-                record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_239] = [__v_13, __v_16];
+                record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_777] = { let __args: [G; IN_777] = [__v_4, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
-                    let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => aiur_fn_240(__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() {
@@ -22139,30 +22327,30 @@ fn aiur_fn_234(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_234] = [__v_18, __v_21];
-                        record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_239] = [__v_18, __v_21];
+                        record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       1u64 => {
                         let __v_18: G = G::from_u64(2);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                         let __v_19: G = __r_arr[0];
-                        let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_19, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[234].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[234].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[234].bump_multiplicity(__i); } let __ret: [G; OUT_234] = unsafe { *(record.function_queries[234].output_at(__i).as_ptr() as *const [G; OUT_234]) }; __ret }, _ => aiur_fn_234(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_19, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[239].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[239].bump_multiplicity(__i); } let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } };
                         let __v_20: G = __r_arr[0];
                         let __v_21: G = __r_arr[1];
                         match __v_20.as_canonical_u64() {
                           0u64 => {
                             let __v_22: G = G::from_u64(0);
-                            let __ret: [G; OUT_234] = [__v_22, __v_21];
-                            record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_239] = [__v_22, __v_21];
+                            record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           1u64 => {
                             let __v_22: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = [__v_17, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[240].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[240].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[240].bump_multiplicity(__i); } let __ret: [G; OUT_240] = unsafe { *(record.function_queries[240].output_at(__i).as_ptr() as *const [G; OUT_240]) }; __ret }, _ => aiur_fn_240(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
                             let __v_23: G = __r_arr[0];
-                            let __ret: [G; OUT_234] = [__v_22, __v_23];
-                            record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_239] = [__v_22, __v_23];
+                            record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
@@ -22180,8 +22368,8 @@ fn aiur_fn_234(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_234] = [__v_14, __v_17];
-                    record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_239] = [__v_14, __v_17];
+                    record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -22195,59 +22383,59 @@ fn aiur_fn_234(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_234] = [__v_9, __v_12];
-        record.function_queries[234].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_239] = [__v_9, __v_12];
+        record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_235: usize = 2;
-const IN_235: usize = 2;
-const OUT_235: usize = 2;
-fn aiur_fn_235(
-  inp: [G; IN_235],
+const INPUT_SIZE_240: usize = 2;
+const IN_240: usize = 2;
+const OUT_240: usize = 2;
+fn aiur_fn_240(
+  inp: [G; IN_240],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_235], ExecError> {
+) -> Result<[G; OUT_240], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_235] = [__v_4, __v_3];
-        record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_240] = [__v_4, __v_3];
+        record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[241].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[241].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[241].bump_multiplicity(__i); } let __ret: [G; OUT_241] = unsafe { *(record.function_queries[241].output_at(__i).as_ptr() as *const [G; OUT_241]) }; __ret }, _ => aiur_fn_241(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_235] = [__v_5, __v_6];
-        record.function_queries[235].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_240] = [__v_5, __v_6];
+        record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_236: usize = 1;
-const IN_236: usize = 1;
-const OUT_236: usize = 2;
-fn aiur_fn_236(
-  inp: [G; IN_236],
+const INPUT_SIZE_241: usize = 1;
+const IN_241: usize = 1;
+const OUT_241: usize = 2;
+fn aiur_fn_241(
+  inp: [G; IN_241],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_236], ExecError> {
+) -> Result<[G; OUT_241], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -22264,7 +22452,7 @@ fn aiur_fn_236(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_209] = { let __args: [G; IN_209] = []; let __cu = unconstrained; let __hit = record.function_queries[209].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[209].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[209].bump_multiplicity(__i); } let __ret: [G; OUT_209] = unsafe { *(record.function_queries[209].output_at(__i).as_ptr() as *const [G; OUT_209]) }; __ret }, _ => aiur_fn_209(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = []; let __cu = unconstrained; let __hit = record.function_queries[214].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[214].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[214].bump_multiplicity(__i); } let __ret: [G; OUT_214] = unsafe { *(record.function_queries[214].output_at(__i).as_ptr() as *const [G; OUT_214]) }; __ret }, _ => aiur_fn_214(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
@@ -22272,8 +22460,8 @@ fn aiur_fn_236(
               0u64 => {
                 let __v_11: G = G::from_u64(0);
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_236] = [__v_11, __v_12];
-                record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_241] = [__v_11, __v_12];
+                record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -22286,18 +22474,18 @@ fn aiur_fn_236(
                   7u64 => {
                     match __v_12.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[237].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[237].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[237].bump_multiplicity(__i); } let __ret: [G; OUT_237] = unsafe { *(record.function_queries[237].output_at(__i).as_ptr() as *const [G; OUT_237]) }; __ret }, _ => aiur_fn_237(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
                         let __v_16: G = __r_arr[1];
-                        let __ret: [G; OUT_236] = [__v_15, __v_16];
-                        record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_241] = [__v_15, __v_16];
+                        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
                         let __v_16: G = G::from_u64(0);
-                        let __ret: [G; OUT_236] = [__v_15, __v_16];
-                        record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_241] = [__v_15, __v_16];
+                        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -22305,8 +22493,8 @@ fn aiur_fn_236(
                   _ => {
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = G::from_u64(0);
-                    let __ret: [G; OUT_236] = [__v_15, __v_16];
-                    record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_241] = [__v_15, __v_16];
+                    record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -22316,8 +22504,8 @@ fn aiur_fn_236(
           _ => {
             let __v_9: G = G::from_u64(0);
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_236] = [__v_9, __v_10];
-            record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_241] = [__v_9, __v_10];
+            record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -22325,23 +22513,23 @@ fn aiur_fn_236(
       _ => {
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_236] = [__v_5, __v_6];
-        record.function_queries[236].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_241] = [__v_5, __v_6];
+        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_237: usize = 1;
-const IN_237: usize = 1;
-const OUT_237: usize = 2;
-fn aiur_fn_237(
-  inp: [G; IN_237],
+const INPUT_SIZE_242: usize = 1;
+const IN_242: usize = 1;
+const OUT_242: usize = 2;
+fn aiur_fn_242(
+  inp: [G; IN_242],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_237], ExecError> {
+) -> Result<[G; OUT_242], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -22379,8 +22567,8 @@ fn aiur_fn_237(
               0u64 => {
                 let __v_26: G = G::from_u64(0);
                 let __v_27: G = G::from_u64(0);
-                let __ret: [G; OUT_237] = [__v_26, __v_27];
-                record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_242] = [__v_26, __v_27];
+                record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -22395,8 +22583,8 @@ fn aiur_fn_237(
                 match __v_33.as_canonical_u64() {
                   1u64 => {
                     let __v_34: G = G::from_u64(1);
-                    let __ret: [G; OUT_237] = [__v_34, __v_31];
-                    record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_242] = [__v_34, __v_31];
+                    record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -22406,8 +22594,8 @@ fn aiur_fn_237(
                       0u64 => {
                         let __v_36: G = G::from_u64(0);
                         let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_237] = [__v_36, __v_37];
-                        record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_242] = [__v_36, __v_37];
+                        record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -22416,15 +22604,15 @@ fn aiur_fn_237(
                         match __v_37.as_canonical_u64() {
                           1u64 => {
                             let __v_38: G = G::from_u64(1);
-                            let __ret: [G; OUT_237] = [__v_38, __v_31];
-                            record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_242] = [__v_38, __v_31];
+                            record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_38: G = G::from_u64(0);
                             let __v_39: G = G::from_u64(0);
-                            let __ret: [G; OUT_237] = [__v_38, __v_39];
-                            record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_242] = [__v_38, __v_39];
+                            record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -22438,8 +22626,8 @@ fn aiur_fn_237(
           _ => {
             let __v_21: G = G::from_u64(0);
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_237] = [__v_21, __v_22];
-            record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_242] = [__v_21, __v_22];
+            record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -22447,23 +22635,23 @@ fn aiur_fn_237(
       _ => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_237] = [__v_11, __v_12];
-        record.function_queries[237].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_242] = [__v_11, __v_12];
+        record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_238: usize = 2;
-const IN_238: usize = 2;
-const OUT_238: usize = 2;
-fn aiur_fn_238(
-  inp: [G; IN_238],
+const INPUT_SIZE_243: usize = 2;
+const IN_243: usize = 2;
+const OUT_243: usize = 2;
+fn aiur_fn_243(
+  inp: [G; IN_243],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_238], ExecError> {
+) -> Result<[G; OUT_243], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -22471,8 +22659,8 @@ fn aiur_fn_238(
     let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_238] = [__v_0, __v_1];
-        record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_243] = [__v_0, __v_1];
+        record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -22480,59 +22668,59 @@ fn aiur_fn_238(
         let __v_5: G = (__v_0 - __v_4);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_238] = [__v_8, __v_9];
-        record.function_queries[238].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_243] = [__v_8, __v_9];
+        record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_239: usize = 1;
-const IN_239: usize = 1;
-const OUT_239: usize = 4;
-fn aiur_fn_239(
-  inp: [G; IN_239],
+const INPUT_SIZE_244: usize = 1;
+const IN_244: usize = 1;
+const OUT_244: usize = 4;
+fn aiur_fn_244(
+  inp: [G; IN_244],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_239], ExecError> {
+) -> Result<[G; OUT_244], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[238].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[238].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[238].bump_multiplicity(__i); } let __ret: [G; OUT_238] = unsafe { *(record.function_queries[238].output_at(__i).as_ptr() as *const [G; OUT_238]) }; __ret }, _ => aiur_fn_238(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
-    let __ret: [G; OUT_239] = [__v_2, __v_5, __v_8, __v_9];
-    record.function_queries[239].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_244] = [__v_2, __v_5, __v_8, __v_9];
+    record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_240: usize = 2;
-const IN_240: usize = 2;
-const OUT_240: usize = 1;
-fn aiur_fn_240(
-  inp: [G; IN_240],
+const INPUT_SIZE_245: usize = 2;
+const IN_245: usize = 2;
+const OUT_245: usize = 1;
+fn aiur_fn_245(
+  inp: [G; IN_245],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_240], ExecError> {
+) -> Result<[G; OUT_245], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = [__v_0]; let __cu = true; let __hit = record.function_queries[239].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_239] = unsafe { *(record.function_queries[239].output_at(__i).as_ptr() as *const [G; OUT_239]) }; __ret }, _ => aiur_fn_239(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_0]; let __cu = true; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__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];
@@ -22587,8 +22775,8 @@ fn aiur_fn_240(
       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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_240] = [__v_38];
-        record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_245] = [__v_38];
+        record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -22604,8 +22792,8 @@ fn aiur_fn_240(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_240] = [__v_46];
-            record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_245] = [__v_46];
+            record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -22625,8 +22813,8 @@ fn aiur_fn_240(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_240] = [__v_52];
-                record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_245] = [__v_52];
+                record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -22646,8 +22834,8 @@ fn aiur_fn_240(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_240] = [__v_56];
-                record.function_queries[240].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_245] = [__v_56];
+                record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -22658,212 +22846,212 @@ fn aiur_fn_240(
   })
 }
 
-const INPUT_SIZE_241: usize = 1;
-const IN_241: usize = 1;
-const OUT_241: usize = 1;
-fn aiur_fn_241(
-  inp: [G; IN_241],
+const INPUT_SIZE_246: usize = 1;
+const IN_246: usize = 1;
+const OUT_246: usize = 1;
+fn aiur_fn_246(
+  inp: [G; IN_246],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_241], ExecError> {
+) -> Result<[G; OUT_246], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_241] = [__v_3];
-        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_246] = [__v_3];
+        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_241] = [__v_5];
-            record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_246] = [__v_5];
+            record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_241] = [__v_7];
-                record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_246] = [__v_7];
+                record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_241] = [__v_9];
-                    record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_246] = [__v_9];
+                    record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_241] = [__v_11];
-                        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_246] = [__v_11];
+                        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_12: G = __r_arr[0];
                         match __v_12.as_canonical_u64() {
                           1u64 => {
                             let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_241] = [__v_13];
-                            record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_246] = [__v_13];
+                            record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
                             let __v_13: G = __r_arr[0];
                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(1);
-                                let __ret: [G; OUT_241] = [__v_15];
-                                record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_246] = [__v_15];
+                                record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } };
                                 let __v_15: G = __r_arr[0];
                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                 let __v_16: G = __r_arr[0];
                                 match __v_16.as_canonical_u64() {
                                   1u64 => {
                                     let __v_17: G = G::from_u64(1);
-                                    let __ret: [G; OUT_241] = [__v_17];
-                                    record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_246] = [__v_17];
+                                    record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } };
                                     let __v_17: G = __r_arr[0];
                                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                     let __v_18: G = __r_arr[0];
                                     match __v_18.as_canonical_u64() {
                                       1u64 => {
                                         let __v_19: G = G::from_u64(1);
-                                        let __ret: [G; OUT_241] = [__v_19];
-                                        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_246] = [__v_19];
+                                        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } };
                                         let __v_19: G = __r_arr[0];
                                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                         let __v_20: G = __r_arr[0];
                                         match __v_20.as_canonical_u64() {
                                           1u64 => {
                                             let __v_21: G = G::from_u64(1);
-                                            let __ret: [G; OUT_241] = [__v_21];
-                                            record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_246] = [__v_21];
+                                            record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } };
                                             let __v_21: G = __r_arr[0];
                                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                             let __v_22: G = __r_arr[0];
                                             match __v_22.as_canonical_u64() {
                                               1u64 => {
                                                 let __v_23: G = G::from_u64(1);
-                                                let __ret: [G; OUT_241] = [__v_23];
-                                                record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_246] = [__v_23];
+                                                record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } };
                                                 let __v_23: G = __r_arr[0];
                                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                 let __v_24: G = __r_arr[0];
                                                 match __v_24.as_canonical_u64() {
                                                   1u64 => {
                                                     let __v_25: G = G::from_u64(1);
-                                                    let __ret: [G; OUT_241] = [__v_25];
-                                                    record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                    let __ret: [G; OUT_246] = [__v_25];
+                                                    record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } };
                                                     let __v_25: G = __r_arr[0];
                                                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                     let __v_26: G = __r_arr[0];
                                                     match __v_26.as_canonical_u64() {
                                                       1u64 => {
                                                         let __v_27: G = G::from_u64(1);
-                                                        let __ret: [G; OUT_241] = [__v_27];
-                                                        record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                        let __ret: [G; OUT_246] = [__v_27];
+                                                        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                         return Ok(__ret);
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } };
                                                         let __v_27: G = __r_arr[0];
                                                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                         let __v_28: G = __r_arr[0];
                                                         match __v_28.as_canonical_u64() {
                                                           1u64 => {
                                                             let __v_29: G = G::from_u64(1);
-                                                            let __ret: [G; OUT_241] = [__v_29];
-                                                            record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                            let __ret: [G; OUT_246] = [__v_29];
+                                                            record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
-                                                            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } };
                                                             let __v_29: G = __r_arr[0];
                                                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                             let __v_30: G = __r_arr[0];
                                                             match __v_30.as_canonical_u64() {
                                                               1u64 => {
                                                                 let __v_31: G = G::from_u64(1);
-                                                                let __ret: [G; OUT_241] = [__v_31];
-                                                                record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                                let __ret: [G; OUT_246] = [__v_31];
+                                                                record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                                 return Ok(__ret);
                                                               },
                                                               _ => {
-                                                                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                                                                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } };
                                                                 let __v_31: G = __r_arr[0];
                                                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                                 let __v_32: G = __r_arr[0];
                                                                 match __v_32.as_canonical_u64() {
                                                                   1u64 => {
                                                                     let __v_33: G = G::from_u64(1);
-                                                                    let __ret: [G; OUT_241] = [__v_33];
-                                                                    record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                                    let __ret: [G; OUT_246] = [__v_33];
+                                                                    record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                                     return Ok(__ret);
                                                                   },
                                                                   _ => {
                                                                     let __v_33: G = G::from_u64(0);
-                                                                    let __ret: [G; OUT_241] = [__v_33];
-                                                                    record.function_queries[241].finish(&inp[..], &__ret[..], !unconstrained);
+                                                                    let __ret: [G; OUT_246] = [__v_33];
+                                                                    record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
                                                                     return Ok(__ret);
                                                                   },
                                                                 }
@@ -22900,54 +23088,54 @@ fn aiur_fn_241(
   })
 }
 
-const INPUT_SIZE_242: usize = 1;
-const IN_242: usize = 1;
-const OUT_242: usize = 1;
-fn aiur_fn_242(
-  inp: [G; IN_242],
+const INPUT_SIZE_247: usize = 1;
+const IN_247: usize = 1;
+const OUT_247: usize = 1;
+fn aiur_fn_247(
+  inp: [G; IN_247],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_242], ExecError> {
+) -> Result<[G; OUT_247], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
@@ -22960,21 +23148,21 @@ fn aiur_fn_242(
     let __v_27: G = (__v_6 + __v_26);
     let __v_28: G = (__v_4 + __v_27);
     let __v_29: G = (__v_2 + __v_28);
-    let __ret: [G; OUT_242] = [__v_29];
-    record.function_queries[242].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_247] = [__v_29];
+    record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_243: usize = 1;
-const IN_243: usize = 1;
-const OUT_243: usize = 2;
-fn aiur_fn_243(
-  inp: [G; IN_243],
+const INPUT_SIZE_248: usize = 1;
+const IN_248: usize = 1;
+const OUT_248: usize = 2;
+fn aiur_fn_248(
+  inp: [G; IN_248],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_243], ExecError> {
+) -> Result<[G; OUT_248], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -22987,8 +23175,8 @@ fn aiur_fn_243(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_243] = [__v_5, __v_3];
-            record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_248] = [__v_5, __v_3];
+            record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -22996,14 +23184,14 @@ fn aiur_fn_243(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_243] = [__v_5, __v_8];
-            record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_248] = [__v_5, __v_8];
+            record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
@@ -23013,8 +23201,8 @@ fn aiur_fn_243(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_243] = [__v_7, __v_10];
-            record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_248] = [__v_7, __v_10];
+            record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -23022,18 +23210,18 @@ fn aiur_fn_243(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_243] = [__v_7, __v_10];
-            record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_248] = [__v_7, __v_10];
+            record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[244].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[244].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[244].bump_multiplicity(__i); } let __ret: [G; OUT_244] = unsafe { *(record.function_queries[244].output_at(__i).as_ptr() as *const [G; OUT_244]) }; __ret }, _ => aiur_fn_244(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_243] = [__v_5, __v_6];
-        record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_248] = [__v_5, __v_6];
+        record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -23041,23 +23229,23 @@ fn aiur_fn_243(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_243] = [__v_5, __v_8];
-        record.function_queries[243].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_248] = [__v_5, __v_8];
+        record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_244: usize = 2;
-const IN_244: usize = 2;
-const OUT_244: usize = 2;
-fn aiur_fn_244(
-  inp: [G; IN_244],
+const INPUT_SIZE_249: usize = 2;
+const IN_249: usize = 2;
+const OUT_249: usize = 2;
+fn aiur_fn_249(
+  inp: [G; IN_249],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_244], ExecError> {
+) -> Result<[G; OUT_249], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23068,22 +23256,22 @@ fn aiur_fn_244(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_244] = [__v_10, __v_11];
-                record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_249] = [__v_10, __v_11];
+                record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -23091,8 +23279,8 @@ fn aiur_fn_244(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_244] = [__v_10, __v_13];
-                record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_249] = [__v_10, __v_13];
+                record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -23102,8 +23290,8 @@ fn aiur_fn_244(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_244] = [__v_8, __v_11];
-            record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_249] = [__v_8, __v_11];
+            record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -23113,44 +23301,44 @@ fn aiur_fn_244(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_244] = [__v_6, __v_9];
-        record.function_queries[244].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_249] = [__v_6, __v_9];
+        record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_245: usize = 1;
-const IN_245: usize = 1;
-const OUT_245: usize = 1;
-fn aiur_fn_245(
-  inp: [G; IN_245],
+const INPUT_SIZE_250: usize = 1;
+const IN_250: usize = 1;
+const OUT_250: usize = 1;
+fn aiur_fn_250(
+  inp: [G; IN_250],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_245], ExecError> {
+) -> Result<[G; OUT_250], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(7);
     let __v_2: G = G::from_u64(0);
     let __v_3: G = G::from_u64(0);
     let __v_4: G = { let __values: [G; 4] = [__v_1, __v_2, __v_0, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_245] = [__v_4];
-    record.function_queries[245].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_250] = [__v_4];
+    record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_246: usize = 1;
-const IN_246: usize = 1;
-const OUT_246: usize = 3;
-fn aiur_fn_246(
-  inp: [G; IN_246],
+const INPUT_SIZE_251: usize = 1;
+const IN_251: usize = 1;
+const OUT_251: usize = 3;
+fn aiur_fn_251(
+  inp: [G; IN_251],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_246], ExecError> {
+) -> Result<[G; OUT_251], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -23167,12 +23355,12 @@ fn aiur_fn_246(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
@@ -23180,14 +23368,14 @@ fn aiur_fn_246(
                   1u64 => {
                     let __v_13: G = G::from_u64(1);
                     let __v_14: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
-                    let __ret: [G; OUT_246] = [__v_13, __v_14, __v_15];
-                    record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_251] = [__v_13, __v_14, __v_15];
+                    record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
@@ -23195,12 +23383,12 @@ fn aiur_fn_246(
                       1u64 => {
                         let __v_15: G = G::from_u64(1);
                         let __v_16: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
                         let __v_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                         let __v_18: G = __r_arr[0];
-                        let __ret: [G; OUT_246] = [__v_15, __v_16, __v_18];
-                        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_251] = [__v_15, __v_16, __v_18];
+                        record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -23209,8 +23397,8 @@ fn aiur_fn_246(
                         let __v_17: G = G::from_u64(1);
                         let __v_18: G = G::from_u64(1);
                         let __v_19: G = { let __values: [G; 10] = [__v_17, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_246] = [__v_15, __v_16, __v_19];
-                        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_251] = [__v_15, __v_16, __v_19];
+                        record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -23223,8 +23411,8 @@ fn aiur_fn_246(
                 let __v_13: G = G::from_u64(1);
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = { let __values: [G; 10] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_246] = [__v_11, __v_12, __v_15];
-                record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_251] = [__v_11, __v_12, __v_15];
+                record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -23235,8 +23423,8 @@ fn aiur_fn_246(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_246] = [__v_9, __v_10, __v_13];
-            record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_251] = [__v_9, __v_10, __v_13];
+            record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -23247,41 +23435,41 @@ fn aiur_fn_246(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_246] = [__v_5, __v_6, __v_9];
-        record.function_queries[246].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_251] = [__v_5, __v_6, __v_9];
+        record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_247: usize = 2;
-const IN_247: usize = 2;
-const OUT_247: usize = 1;
-fn aiur_fn_247(
-  inp: [G; IN_247],
+const INPUT_SIZE_252: usize = 2;
+const IN_252: usize = 2;
+const OUT_252: usize = 1;
+fn aiur_fn_252(
+  inp: [G; IN_252],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_247], ExecError> {
+) -> Result<[G; OUT_252], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__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_0 * __v_5);
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     break '__mc_0 [__v_7];
   },
   _ => {
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     break '__mc_0 [__v_7];
   },
@@ -23293,9 +23481,9 @@ fn aiur_fn_247(
     break '__mc_1 [__v_2];
   },
   _ => {
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     break '__mc_1 [__v_9];
   },
@@ -23309,25 +23497,25 @@ fn aiur_fn_247(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_14: G = G::from_u64(0);
     let __v_15: G = { let __values: [G; 4] = [__v_10, __v_7, __v_13, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__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_9, __v_15, __v_16, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_247] = [__v_18];
-    record.function_queries[247].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_252] = [__v_18];
+    record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_248: usize = 4;
-const IN_248: usize = 4;
-const OUT_248: usize = 1;
-fn aiur_fn_248(
-  inp: [G; IN_248],
+const INPUT_SIZE_253: usize = 4;
+const IN_253: usize = 4;
+const OUT_253: usize = 1;
+fn aiur_fn_253(
+  inp: [G; IN_253],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_248], ExecError> {
+) -> Result<[G; OUT_253], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -23336,34 +23524,34 @@ fn aiur_fn_248(
     let __v_4: G = (__v_0 - __v_2);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_248] = [__v_6];
-        record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_253] = [__v_6];
+        record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_248] = [__v_7];
-            record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_253] = [__v_7];
+            record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_248] = [__v_7];
-            record.function_queries[248].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_253] = [__v_7];
+            record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -23372,54 +23560,54 @@ fn aiur_fn_248(
   })
 }
 
-const INPUT_SIZE_249: usize = 3;
-const IN_249: usize = 3;
-const OUT_249: usize = 1;
-fn aiur_fn_249(
-  inp: [G; IN_249],
+const INPUT_SIZE_254: usize = 3;
+const IN_254: usize = 3;
+const OUT_254: usize = 1;
+fn aiur_fn_254(
+  inp: [G; IN_254],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_249], ExecError> {
+) -> Result<[G; OUT_254], ExecError> {
   stacker::maybe_grow(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_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_249] = [__v_4];
-        record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_254] = [__v_4];
+        record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__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_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 - __v_6);
         let __v_8: G = (__v_0 * __v_7);
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_249] = [__v_11];
-            record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_254] = [__v_11];
+            record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_9, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_249] = [__v_10];
-            record.function_queries[249].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_254] = [__v_10];
+            record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -23428,21 +23616,21 @@ fn aiur_fn_249(
   })
 }
 
-const INPUT_SIZE_250: usize = 4;
-const IN_250: usize = 4;
-const OUT_250: usize = 1;
-fn aiur_fn_250(
-  inp: [G; IN_250],
+const INPUT_SIZE_255: usize = 4;
+const IN_255: usize = 4;
+const OUT_255: usize = 1;
+fn aiur_fn_255(
+  inp: [G; IN_255],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_250], ExecError> {
+) -> Result<[G; OUT_255], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
@@ -23450,25 +23638,25 @@ fn aiur_fn_250(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_250] = [__v_9];
-        record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_255] = [__v_9];
+        record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__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_133] = { let __args: [G; IN_133] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = (__v_7 - __v_8);
         let __v_10: G = (__v_0 * __v_9);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -23484,54 +23672,54 @@ fn aiur_fn_250(
         let __v_15: G = (__v_2 - __v_14);
         let __v_16: G = (__v_0 + __v_15);
         let __v_17: G = G::from_u64(1);
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __v_19: G = (__v_17 - __v_18);
         let __v_20: G = (__v_16 * __v_19);
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_20, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_20, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __ret: [G; OUT_250] = [__v_21];
-        record.function_queries[250].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_255] = [__v_21];
+        record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_251: usize = 3;
-const IN_251: usize = 3;
-const OUT_251: usize = 1;
-fn aiur_fn_251(
-  inp: [G; IN_251],
+const INPUT_SIZE_256: usize = 3;
+const IN_256: usize = 3;
+const OUT_256: usize = 1;
+fn aiur_fn_256(
+  inp: [G; IN_256],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_251], ExecError> {
+) -> Result<[G; OUT_256], ExecError> {
   stacker::maybe_grow(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_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_251] = [__v_4];
-        record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_256] = [__v_4];
+        record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__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_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 - __v_6);
         let __v_8: G = (__v_0 * __v_7);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     break '__mc_0 [__v_9];
   },
@@ -23554,29 +23742,29 @@ fn aiur_fn_251(
         let __v_20: G = G::from_u64(1);
         let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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; 10] = [__v_10, __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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_23, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_23, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_24, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_24, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         match __v_25.as_canonical_u64() {
           1u64 => {
             let __v_26: G = G::from_u64(1);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_26, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_251] = [__v_28];
-            record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_256] = [__v_28];
+            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_26, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __ret: [G; OUT_251] = [__v_27];
-            record.function_queries[251].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_256] = [__v_27];
+            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -23585,20 +23773,20 @@ fn aiur_fn_251(
   })
 }
 
-const INPUT_SIZE_252: usize = 3;
-const IN_252: usize = 3;
-const OUT_252: usize = 1;
-fn aiur_fn_252(
-  inp: [G; IN_252],
+const INPUT_SIZE_257: usize = 3;
+const IN_257: usize = 3;
+const OUT_257: usize = 1;
+fn aiur_fn_257(
+  inp: [G; IN_257],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_252], ExecError> {
+) -> Result<[G; OUT_257], ExecError> {
   stacker::maybe_grow(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_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
@@ -23606,23 +23794,23 @@ fn aiur_fn_252(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_252] = [__v_8];
-        record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_257] = [__v_8];
+        record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__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_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 - __v_6);
         let __v_8: G = (__v_0 * __v_7);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_8.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     break '__mc_0 [__v_9];
   },
@@ -23632,16 +23820,16 @@ fn aiur_fn_252(
 }
  };
         let __v_9: G = __mc_out___mc_0[0];
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__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_133] = { let __args: [G; IN_133] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = (__v_11 - __v_12);
         let __v_14: G = (__v_0 * __v_13);
         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_14.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     break '__mc_1 [__v_15];
   },
@@ -23652,7 +23840,7 @@ fn aiur_fn_252(
  };
         let __v_15: G = __mc_out___mc_1[0];
         let __v_16: G = G::from_u64(1);
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         let __v_18: G = (__v_16 - __v_17);
         let __v_19: G = (__v_0 * __v_18);
@@ -23669,18 +23857,18 @@ fn aiur_fn_252(
         let __v_30: G = G::from_u64(1);
         let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
-        let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_33, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_34, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_34, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
         let __v_35: G = __r_arr[0];
         match __v_35.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __ret: [G; OUT_252] = [__v_36];
-            record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_257] = [__v_36];
+            record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -23698,10 +23886,10 @@ fn aiur_fn_252(
             let __v_47: G = G::from_u64(1);
             let __v_48: G = { let __values: [G; 10] = [__v_46, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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; 10] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_48]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_19, __v_15, __v_36, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __ret: [G; OUT_252] = [__v_50];
-            record.function_queries[252].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_257] = [__v_50];
+            record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -23710,28 +23898,28 @@ fn aiur_fn_252(
   })
 }
 
-const INPUT_SIZE_253: usize = 3;
-const IN_253: usize = 3;
-const OUT_253: usize = 2;
-fn aiur_fn_253(
-  inp: [G; IN_253],
+const INPUT_SIZE_258: usize = 3;
+const IN_258: usize = 3;
+const OUT_258: usize = 2;
+fn aiur_fn_258(
+  inp: [G; IN_258],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_253], ExecError> {
+) -> Result<[G; OUT_258], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
@@ -23747,27 +23935,27 @@ fn aiur_fn_253(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_253] = [__v_12, __v_16];
-            record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_258] = [__v_12, __v_16];
+            record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
             match __v_14.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = []; let __cu = unconstrained; let __hit = record.function_queries[160].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[160].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[160].bump_multiplicity(__i); } let __ret: [G; OUT_160] = unsafe { *(record.function_queries[160].output_at(__i).as_ptr() as *const [G; OUT_160]) }; __ret }, _ => aiur_fn_160(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
                 let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_18.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     break '__mc_0 [__v_19];
   },
@@ -23775,11 +23963,11 @@ fn aiur_fn_253(
     let __v_19: G = G::from_u64(1);
     let __v_20: G = (__v_19 - __v_15);
     let __v_21: G = G::from_u64(1);
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
     let __v_23: G = (__v_21 - __v_22);
     let __v_24: G = (__v_20 * __v_23);
-    let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_24, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_24, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
     break '__mc_0 [__v_25];
   },
@@ -23788,12 +23976,12 @@ fn aiur_fn_253(
                 let __v_19: G = __mc_out___mc_0[0];
                 let __v_20: G = G::from_u64(1);
                 let __v_21: G = G::from_u64(1);
-                let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_253] = [__v_20, __v_23];
-                record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_258] = [__v_20, __v_23];
+                record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -23802,8 +23990,8 @@ fn aiur_fn_253(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_253] = [__v_17, __v_21];
-                record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_258] = [__v_17, __v_21];
+                record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -23820,25 +24008,25 @@ fn aiur_fn_253(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_253] = [__v_12, __v_16];
-            record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_258] = [__v_12, __v_16];
+            record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
             let __v_16: G = __r_arr[2];
             match __v_14.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_0, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
                 let __v_18: G = __r_arr[1];
-                let __ret: [G; OUT_253] = [__v_17, __v_18];
-                record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_258] = [__v_17, __v_18];
+                record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -23847,8 +24035,8 @@ fn aiur_fn_253(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_253] = [__v_17, __v_21];
-                record.function_queries[253].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_258] = [__v_17, __v_21];
+                record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -23859,29 +24047,29 @@ fn aiur_fn_253(
   })
 }
 
-const INPUT_SIZE_254: usize = 4;
-const IN_254: usize = 4;
-const OUT_254: usize = 2;
-fn aiur_fn_254(
-  inp: [G; IN_254],
+const INPUT_SIZE_259: usize = 4;
+const IN_259: usize = 4;
+const OUT_259: usize = 2;
+fn aiur_fn_259(
+  inp: [G; IN_259],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_254], ExecError> {
+) -> Result<[G; OUT_259], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
@@ -23890,31 +24078,31 @@ fn aiur_fn_254(
     match __v_11.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_17.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     break '__mc_0 [__v_18];
   },
   _ => {
-    let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     match __v_19.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         break '__mc_0 [__v_20];
       },
@@ -23933,15 +24121,15 @@ fn aiur_fn_254(
         let __v_31: G = { let __values: [G; 10] = [__v_29, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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; 10] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(1);
-        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_15, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_35: G = __r_arr[0];
         let __v_36: G = (__v_33 - __v_35);
         let __v_37: G = (__v_2 * __v_36);
-        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
-        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
         break '__mc_0 [__v_39];
       },
@@ -23952,12 +24140,12 @@ fn aiur_fn_254(
             let __v_18: G = __mc_out___mc_0[0];
             let __v_19: G = G::from_u64(1);
             let __v_20: G = G::from_u64(2);
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_254] = [__v_19, __v_22];
-            record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_259] = [__v_19, __v_22];
+            record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -23966,34 +24154,34 @@ fn aiur_fn_254(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_254] = [__v_16, __v_20];
-            record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_259] = [__v_16, __v_20];
+            record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_12: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[246].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[246].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[246].bump_multiplicity(__i); } let __ret: [G; OUT_246] = unsafe { *(record.function_queries[246].output_at(__i).as_ptr() as *const [G; OUT_246]) }; __ret }, _ => aiur_fn_246(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[251].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[251].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[251].bump_multiplicity(__i); } let __ret: [G; OUT_251] = unsafe { *(record.function_queries[251].output_at(__i).as_ptr() as *const [G; OUT_251]) }; __ret }, _ => aiur_fn_251(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         let __v_16: G = __r_arr[2];
         match __v_14.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = []; let __cu = unconstrained; let __hit = record.function_queries[157].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[157].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[157].bump_multiplicity(__i); } let __ret: [G; OUT_157] = unsafe { *(record.function_queries[157].output_at(__i).as_ptr() as *const [G; OUT_157]) }; __ret }, _ => aiur_fn_157(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_18.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     break '__mc_1 [__v_19];
   },
   _ => {
-    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = []; let __cu = unconstrained; let __hit = record.function_queries[158].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[158].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[158].bump_multiplicity(__i); } let __ret: [G; OUT_158] = unsafe { *(record.function_queries[158].output_at(__i).as_ptr() as *const [G; OUT_158]) }; __ret }, _ => aiur_fn_158(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
@@ -24002,16 +24190,16 @@ fn aiur_fn_254(
         let __v_21: G = G::from_u64(1);
         let __v_22: G = (__v_21 - __v_15);
         let __v_23: G = G::from_u64(1);
-        let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
         let __v_25: G = (__v_23 - __v_24);
         let __v_26: G = (__v_22 * __v_25);
-        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_2, __v_3, __v_26, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
         break '__mc_1 [__v_27];
       },
       _ => {
-        let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = []; let __cu = unconstrained; let __hit = record.function_queries[159].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[159].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[159].bump_multiplicity(__i); } let __ret: [G; OUT_159] = unsafe { *(record.function_queries[159].output_at(__i).as_ptr() as *const [G; OUT_159]) }; __ret }, _ => aiur_fn_159(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
@@ -24023,34 +24211,34 @@ fn aiur_fn_254(
             let __v_26: G = (__v_15 - __v_25);
             let __v_27: G = (__v_2 + __v_26);
             let __v_28: G = G::from_u64(1);
-            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
             let __v_30: G = (__v_28 - __v_29);
             let __v_31: G = G::from_u64(1);
-            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = (__v_31 - __v_32);
             let __v_34: G = (__v_30 * __v_33);
             let __v_35: G = (__v_27 * __v_34);
-            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = [__v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[252].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[252].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[252].bump_multiplicity(__i); } let __ret: [G; OUT_252] = unsafe { *(record.function_queries[252].output_at(__i).as_ptr() as *const [G; OUT_252]) }; __ret }, _ => aiur_fn_252(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
             break '__mc_1 [__v_37];
           },
           _ => {
-            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = []; let __cu = unconstrained; let __hit = record.function_queries[161].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[161].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[161].bump_multiplicity(__i); } let __ret: [G; OUT_161] = unsafe { *(record.function_queries[161].output_at(__i).as_ptr() as *const [G; OUT_161]) }; __ret }, _ => aiur_fn_161(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
             match __v_24.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[249].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[249].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[249].bump_multiplicity(__i); } let __ret: [G; OUT_249] = unsafe { *(record.function_queries[249].output_at(__i).as_ptr() as *const [G; OUT_249]) }; __ret }, _ => aiur_fn_249(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = [__v_2, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[254].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[254].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[254].bump_multiplicity(__i); } let __ret: [G; OUT_254] = unsafe { *(record.function_queries[254].output_at(__i).as_ptr() as *const [G; OUT_254]) }; __ret }, _ => aiur_fn_254(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
                 break '__mc_1 [__v_25];
               },
               _ => {
-                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
                 break '__mc_1 [__v_25];
               },
@@ -24065,12 +24253,12 @@ fn aiur_fn_254(
             let __v_19: G = __mc_out___mc_1[0];
             let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(2);
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_254] = [__v_20, __v_23];
-            record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_259] = [__v_20, __v_23];
+            record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -24079,8 +24267,8 @@ fn aiur_fn_254(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_254] = [__v_17, __v_21];
-            record.function_queries[254].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_259] = [__v_17, __v_21];
+            record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -24089,15 +24277,15 @@ fn aiur_fn_254(
   })
 }
 
-const INPUT_SIZE_255: usize = 2;
-const IN_255: usize = 2;
-const OUT_255: usize = 1;
-fn aiur_fn_255(
-  inp: [G; IN_255],
+const INPUT_SIZE_260: usize = 2;
+const IN_260: usize = 2;
+const OUT_260: usize = 1;
+fn aiur_fn_260(
+  inp: [G; IN_260],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_255], ExecError> {
+) -> Result<[G; OUT_260], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24107,18 +24295,18 @@ fn aiur_fn_255(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_255] = [__v_0];
-        record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_260] = [__v_0];
+        record.function_queries[260].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_255] = [__v_8];
-        record.function_queries[255].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_260] = [__v_8];
+        record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -24128,264 +24316,264 @@ fn aiur_fn_255(
   })
 }
 
-const INPUT_SIZE_256: usize = 3;
-const IN_256: usize = 3;
-const OUT_256: usize = 2;
-fn aiur_fn_256(
-  inp: [G; IN_256],
+const INPUT_SIZE_261: usize = 3;
+const IN_261: usize = 3;
+const OUT_261: usize = 2;
+fn aiur_fn_261(
+  inp: [G; IN_261],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_256], ExecError> {
+) -> Result<[G; OUT_261], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_256] = [__v_5, __v_8];
-        record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_261] = [__v_5, __v_8];
+        record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_256] = [__v_7, __v_10];
-            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_261] = [__v_7, __v_10];
+            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[134].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[134].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[134].bump_multiplicity(__i); } let __ret: [G; OUT_134] = unsafe { *(record.function_queries[134].output_at(__i).as_ptr() as *const [G; OUT_134]) }; __ret }, _ => aiur_fn_134(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_256] = [__v_9, __v_12];
-                record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_261] = [__v_9, __v_12];
+                record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 match __v_10.as_canonical_u64() {
                   1u64 => {
                     let __v_11: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[135].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[135].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[135].bump_multiplicity(__i); } let __ret: [G; OUT_135] = unsafe { *(record.function_queries[135].output_at(__i).as_ptr() as *const [G; OUT_135]) }; __ret }, _ => aiur_fn_135(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[140].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[140].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[140].bump_multiplicity(__i); } let __ret: [G; OUT_140] = unsafe { *(record.function_queries[140].output_at(__i).as_ptr() as *const [G; OUT_140]) }; __ret }, _ => aiur_fn_140(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
-                    let __ret: [G; OUT_256] = [__v_11, __v_14];
-                    record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_261] = [__v_11, __v_14];
+                    record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
                     let __v_11: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[136].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[136].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[136].bump_multiplicity(__i); } let __ret: [G; OUT_136] = unsafe { *(record.function_queries[136].output_at(__i).as_ptr() as *const [G; OUT_136]) }; __ret }, _ => aiur_fn_136(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[141].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[141].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[141].bump_multiplicity(__i); } let __ret: [G; OUT_141] = unsafe { *(record.function_queries[141].output_at(__i).as_ptr() as *const [G; OUT_141]) }; __ret }, _ => aiur_fn_141(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
-                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
-                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                         let __v_16: G = __r_arr[0];
-                        let __ret: [G; OUT_256] = [__v_13, __v_16];
-                        record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_261] = [__v_13, __v_16];
+                        record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } };
                         let __v_13: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
                         match __v_14.as_canonical_u64() {
                           1u64 => {
                             let __v_15: G = G::from_u64(1);
-                            let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[137].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[137].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[137].bump_multiplicity(__i); } let __ret: [G; OUT_137] = unsafe { *(record.function_queries[137].output_at(__i).as_ptr() as *const [G; OUT_137]) }; __ret }, _ => aiur_fn_137(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
-                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                             let __v_17: G = __r_arr[0];
-                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                             let __v_18: G = __r_arr[0];
-                            let __ret: [G; OUT_256] = [__v_15, __v_18];
-                            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_261] = [__v_15, __v_18];
+                            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } };
                             let __v_15: G = __r_arr[0];
                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
                             match __v_16.as_canonical_u64() {
                               1u64 => {
                                 let __v_17: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
                                 let __v_18: G = __r_arr[0];
-                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                                 let __v_19: G = __r_arr[0];
-                                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                                 let __v_20: G = __r_arr[0];
-                                let __ret: [G; OUT_256] = [__v_17, __v_20];
-                                record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_261] = [__v_17, __v_20];
+                                record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } };
                                 let __v_17: G = __r_arr[0];
                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                 let __v_18: G = __r_arr[0];
                                 match __v_18.as_canonical_u64() {
                                   1u64 => {
                                     let __v_19: G = G::from_u64(1);
-                                    let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[142].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[142].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[142].bump_multiplicity(__i); } let __ret: [G; OUT_142] = unsafe { *(record.function_queries[142].output_at(__i).as_ptr() as *const [G; OUT_142]) }; __ret }, _ => aiur_fn_142(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } };
                                     let __v_20: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                                     let __v_21: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                                     let __v_22: G = __r_arr[0];
-                                    let __ret: [G; OUT_256] = [__v_19, __v_22];
-                                    record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_261] = [__v_19, __v_22];
+                                    record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } };
                                     let __v_19: G = __r_arr[0];
                                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                     let __v_20: G = __r_arr[0];
                                     match __v_20.as_canonical_u64() {
                                       1u64 => {
                                         let __v_21: G = G::from_u64(1);
-                                        let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[143].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[143].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[143].bump_multiplicity(__i); } let __ret: [G; OUT_143] = unsafe { *(record.function_queries[143].output_at(__i).as_ptr() as *const [G; OUT_143]) }; __ret }, _ => aiur_fn_143(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
                                         let __v_22: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                                         let __v_23: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                                         let __v_24: G = __r_arr[0];
-                                        let __ret: [G; OUT_256] = [__v_21, __v_24];
-                                        record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_261] = [__v_21, __v_24];
+                                        record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } };
                                         let __v_21: G = __r_arr[0];
                                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                         let __v_22: G = __r_arr[0];
                                         match __v_22.as_canonical_u64() {
                                           1u64 => {
                                             let __v_23: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[144].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[144].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[144].bump_multiplicity(__i); } let __ret: [G; OUT_144] = unsafe { *(record.function_queries[144].output_at(__i).as_ptr() as *const [G; OUT_144]) }; __ret }, _ => aiur_fn_144(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } };
                                             let __v_24: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                                             let __v_25: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                                             let __v_26: G = __r_arr[0];
-                                            let __ret: [G; OUT_256] = [__v_23, __v_26];
-                                            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_261] = [__v_23, __v_26];
+                                            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } };
                                             let __v_23: G = __r_arr[0];
                                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                             let __v_24: G = __r_arr[0];
                                             match __v_24.as_canonical_u64() {
                                               1u64 => {
                                                 let __v_25: G = G::from_u64(1);
-                                                let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[145].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[145].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[145].bump_multiplicity(__i); } let __ret: [G; OUT_145] = unsafe { *(record.function_queries[145].output_at(__i).as_ptr() as *const [G; OUT_145]) }; __ret }, _ => aiur_fn_145(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } };
                                                 let __v_26: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                                                 let __v_27: G = __r_arr[0];
-                                                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                                                 let __v_28: G = __r_arr[0];
-                                                let __ret: [G; OUT_256] = [__v_25, __v_28];
-                                                record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_261] = [__v_25, __v_28];
+                                                record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } };
                                                 let __v_25: G = __r_arr[0];
                                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                 let __v_26: G = __r_arr[0];
                                                 match __v_26.as_canonical_u64() {
                                                   1u64 => {
                                                     let __v_27: G = G::from_u64(1);
-                                                    let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[146].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[146].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[146].bump_multiplicity(__i); } let __ret: [G; OUT_146] = unsafe { *(record.function_queries[146].output_at(__i).as_ptr() as *const [G; OUT_146]) }; __ret }, _ => aiur_fn_146(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } };
                                                     let __v_28: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                                                     let __v_29: G = __r_arr[0];
-                                                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                                                     let __v_30: G = __r_arr[0];
-                                                    let __ret: [G; OUT_256] = [__v_27, __v_30];
-                                                    record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                                    let __ret: [G; OUT_261] = [__v_27, __v_30];
+                                                    record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } };
                                                     let __v_27: G = __r_arr[0];
                                                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                     let __v_28: G = __r_arr[0];
                                                     match __v_28.as_canonical_u64() {
                                                       1u64 => {
                                                         let __v_29: G = G::from_u64(1);
-                                                        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
                                                         let __v_30: G = __r_arr[0];
-                                                        let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } };
                                                         let __v_31: G = __r_arr[0];
-                                                        let __ret: [G; OUT_256] = [__v_29, __v_31];
-                                                        record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                                        let __ret: [G; OUT_261] = [__v_29, __v_31];
+                                                        record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                                         return Ok(__ret);
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } };
                                                         let __v_29: G = __r_arr[0];
                                                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                         let __v_30: G = __r_arr[0];
                                                         match __v_30.as_canonical_u64() {
                                                           1u64 => {
                                                             let __v_31: G = G::from_u64(1);
-                                                            let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
                                                             let __v_32: G = __r_arr[0];
-                                                            let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[198].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[198].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[198].bump_multiplicity(__i); } let __ret: [G; OUT_198] = unsafe { *(record.function_queries[198].output_at(__i).as_ptr() as *const [G; OUT_198]) }; __ret }, _ => aiur_fn_198(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } };
                                                             let __v_33: G = __r_arr[0];
-                                                            let __ret: [G; OUT_256] = [__v_31, __v_33];
-                                                            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                                            let __ret: [G; OUT_261] = [__v_31, __v_33];
+                                                            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                                             return Ok(__ret);
                                                           },
                                                           _ => {
@@ -24394,8 +24582,8 @@ fn aiur_fn_256(
                                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                            let __ret: [G; OUT_256] = [__v_31, __v_35];
-                                                            record.function_queries[256].finish(&inp[..], &__ret[..], !unconstrained);
+                                                            let __ret: [G; OUT_261] = [__v_31, __v_35];
+                                                            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
                                                             return Ok(__ret);
                                                           },
                                                         }
@@ -24428,15 +24616,15 @@ fn aiur_fn_256(
   })
 }
 
-const INPUT_SIZE_257: usize = 2;
-const IN_257: usize = 2;
-const OUT_257: usize = 3;
-fn aiur_fn_257(
-  inp: [G; IN_257],
+const INPUT_SIZE_262: usize = 2;
+const IN_262: usize = 2;
+const OUT_262: usize = 3;
+fn aiur_fn_262(
+  inp: [G; IN_262],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_257], ExecError> {
+) -> Result<[G; OUT_262], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24447,7 +24635,7 @@ fn aiur_fn_257(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
@@ -24457,22 +24645,22 @@ fn aiur_fn_257(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_257] = [__v_8, __v_0, __v_11];
-            record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_262] = [__v_8, __v_0, __v_11];
+            record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_777] = { let __args: [G; IN_777] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                 let __v_15: G = __loaded[0];
@@ -24484,8 +24672,8 @@ fn aiur_fn_257(
                     match __v_16.as_canonical_u64() {
                       0u64 => {
                         let __v_19: G = G::from_u64(1);
-                        let __ret: [G; OUT_257] = [__v_19, __v_12, __v_17];
-                        record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_262] = [__v_19, __v_12, __v_17];
+                        record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -24493,8 +24681,8 @@ fn aiur_fn_257(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22];
-                        record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_262] = [__v_19, __v_0, __v_22];
+                        record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -24504,8 +24692,8 @@ fn aiur_fn_257(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_257] = [__v_19, __v_0, __v_22];
-                    record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_262] = [__v_19, __v_0, __v_22];
+                    record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -24515,8 +24703,8 @@ fn aiur_fn_257(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_257] = [__v_11, __v_0, __v_14];
-                record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_262] = [__v_11, __v_0, __v_14];
+                record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -24528,23 +24716,23 @@ fn aiur_fn_257(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_257] = [__v_6, __v_0, __v_9];
-        record.function_queries[257].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_262] = [__v_6, __v_0, __v_9];
+        record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_258: usize = 2;
-const IN_258: usize = 2;
-const OUT_258: usize = 1;
-fn aiur_fn_258(
-  inp: [G; IN_258],
+const INPUT_SIZE_263: usize = 2;
+const IN_263: usize = 2;
+const OUT_263: usize = 1;
+fn aiur_fn_263(
+  inp: [G; IN_263],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_258], ExecError> {
+) -> Result<[G; OUT_263], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24561,32 +24749,32 @@ fn aiur_fn_258(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[128].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[128].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[128].bump_multiplicity(__i); } let __ret: [G; OUT_128] = unsafe { *(record.function_queries[128].output_at(__i).as_ptr() as *const [G; OUT_128]) }; __ret }, _ => aiur_fn_128(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = G::from_u64(2);
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     match __v_24.as_canonical_u64() {
       1u64 => {
         let __v_25: G = G::from_u64(3);
         let __v_26: G = G::from_u64(0);
         let __v_27: G = { let __values: [G; 4] = [__v_25, __v_23, __v_0, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_258] = [__v_27];
-        record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_263] = [__v_27];
+        record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_25: G = G::from_u64(2);
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__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);
@@ -24606,23 +24794,23 @@ fn aiur_fn_258(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_258] = [__v_44];
-        record.function_queries[258].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_263] = [__v_44];
+        record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_259: usize = 1;
-const IN_259: usize = 1;
-const OUT_259: usize = 1;
-fn aiur_fn_259(
-  inp: [G; IN_259],
+const INPUT_SIZE_264: usize = 1;
+const IN_264: usize = 1;
+const OUT_264: usize = 1;
+fn aiur_fn_264(
+  inp: [G; IN_264],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_259], ExecError> {
+) -> Result<[G; OUT_264], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -24632,12 +24820,12 @@ fn aiur_fn_259(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       7u64 => {
-        let __ret: [G; OUT_259] = [__v_0];
-        record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_264] = [__v_0];
+        record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -24647,41 +24835,41 @@ fn aiur_fn_259(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[257].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[257].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[257].bump_multiplicity(__i); } let __ret: [G; OUT_257] = unsafe { *(record.function_queries[257].output_at(__i).as_ptr() as *const [G; OUT_257]) }; __ret }, _ => aiur_fn_257(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[262].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[262].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => aiur_fn_262(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             let __v_13: G = __r_arr[2];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
                 match __v_15.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_259] = [__v_0];
-                    record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_264] = [__v_0];
+                    record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_12, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = [__v_12, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[263].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[263].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[263].bump_multiplicity(__i); } let __ret: [G; OUT_263] = unsafe { *(record.function_queries[263].output_at(__i).as_ptr() as *const [G; OUT_263]) }; __ret }, _ => aiur_fn_263(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
-                    let __ret: [G; OUT_259] = [__v_16];
-                    record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_264] = [__v_16];
+                    record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_259] = [__v_0];
-                record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_264] = [__v_0];
+                record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_259] = [__v_0];
-            record.function_queries[259].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_264] = [__v_0];
+            record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -24690,33 +24878,33 @@ fn aiur_fn_259(
   })
 }
 
-const INPUT_SIZE_260: usize = 3;
-const IN_260: usize = 3;
-const OUT_260: usize = 2;
-fn aiur_fn_260(
-  inp: [G; IN_260],
+const INPUT_SIZE_265: usize = 3;
+const IN_265: usize = 3;
+const OUT_265: usize = 2;
+fn aiur_fn_265(
+  inp: [G; IN_265],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_260], ExecError> {
+) -> Result<[G; OUT_265], ExecError> {
   stacker::maybe_grow(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_133] = { let __args: [G; IN_133] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_260] = [__v_4, __v_5];
-        record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_265] = [__v_4, __v_5];
+        record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(2);
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__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);
@@ -24727,30 +24915,30 @@ fn aiur_fn_260(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_255] = { let __args: [G; IN_255] = [__v_17, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_17, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_260] = [__v_18, __v_19];
-        record.function_queries[260].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_265] = [__v_18, __v_19];
+        record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_261: usize = 1;
-const IN_261: usize = 1;
-const OUT_261: usize = 1;
-fn aiur_fn_261(
-  inp: [G; IN_261],
+const INPUT_SIZE_266: usize = 1;
+const IN_266: usize = 1;
+const OUT_266: usize = 1;
+fn aiur_fn_266(
+  inp: [G; IN_266],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_261], ExecError> {
+) -> Result<[G; OUT_266], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -24767,7 +24955,7 @@ fn aiur_fn_261(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -24777,26 +24965,26 @@ fn aiur_fn_261(
             let __v_14: G = __loaded[3];
             match __v_11.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   0u64 => {
                     let __v_17: G = G::from_u64(0);
-                    let __ret: [G; OUT_261] = [__v_17];
-                    record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_266] = [__v_17];
+                    record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_777] = { let __args: [G; IN_777] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                         let __v_22: G = __loaded[0];
@@ -24806,22 +24994,22 @@ fn aiur_fn_261(
                         match __v_22.as_canonical_u64() {
                           0u64 => {
                             let __v_26: G = G::from_bool((__v_23 == G::ZERO));
-                            let __ret: [G; OUT_261] = [__v_26];
-                            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_266] = [__v_26];
+                            record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_26: G = G::from_u64(0);
-                            let __ret: [G; OUT_261] = [__v_26];
-                            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_266] = [__v_26];
+                            record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_20: G = G::from_u64(0);
-                        let __ret: [G; OUT_261] = [__v_20];
-                        record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_266] = [__v_20];
+                        record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -24830,39 +25018,39 @@ fn aiur_fn_261(
               },
               _ => {
                 let __v_15: G = G::from_u64(0);
-                let __ret: [G; OUT_261] = [__v_15];
-                record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_266] = [__v_15];
+                record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_261] = [__v_9];
-            record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_266] = [__v_9];
+            record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_261] = [__v_5];
-        record.function_queries[261].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_266] = [__v_5];
+        record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_262: usize = 5;
-const IN_262: usize = 5;
-const OUT_262: usize = 2;
-fn aiur_fn_262(
-  inp: [G; IN_262],
+const INPUT_SIZE_267: usize = 5;
+const IN_267: usize = 5;
+const OUT_267: usize = 2;
+fn aiur_fn_267(
+  inp: [G; IN_267],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_262], ExecError> {
+) -> Result<[G; OUT_267], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -24878,14 +25066,14 @@ fn aiur_fn_262(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_262] = [__v_7, __v_11];
-        record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_267] = [__v_7, __v_11];
+        record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
@@ -24895,17 +25083,17 @@ fn aiur_fn_262(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_262] = [__v_10, __v_14];
-            record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_267] = [__v_10, __v_14];
+            record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_10: G = (__v_1 + __v_2);
             let __v_11: G = G::from_u64(1);
             let __v_12: G = (__v_10 + __v_11);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[261].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => aiur_fn_261(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             match __v_14.as_canonical_u64() {
               0u64 => {
@@ -24914,39 +25102,39 @@ fn aiur_fn_262(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_262] = [__v_15, __v_19];
-                record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_267] = [__v_15, __v_19];
+                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_786] = { let __args: [G; IN_786] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
                 let __v_20: G = __r_arr[1];
                 match __v_19.as_canonical_u64() {
                   1u64 => {
                     let __v_21: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_20, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_20, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
                     let __v_22: G = __r_arr[0];
-                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                     let __v_23: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_23, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_23, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_24: G = __r_arr[0];
-                    let __ret: [G; OUT_262] = [__v_21, __v_24];
-                    record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_267] = [__v_21, __v_24];
+                    record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_15, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[265].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[265].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => aiur_fn_265(__args, record, io_buffer, __cu)? } };
                     let __v_21: G = __r_arr[0];
                     let __v_22: G = __r_arr[1];
-                    let __ret: [G; OUT_262] = [__v_21, __v_22];
-                    record.function_queries[262].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_267] = [__v_21, __v_22];
+                    record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -24962,26 +25150,26 @@ fn aiur_fn_262(
   })
 }
 
-const INPUT_SIZE_263: usize = 3;
-const IN_263: usize = 3;
-const OUT_263: usize = 2;
-fn aiur_fn_263(
-  inp: [G; IN_263],
+const INPUT_SIZE_268: usize = 3;
+const IN_268: usize = 3;
+const OUT_268: usize = 2;
+fn aiur_fn_268(
+  inp: [G; IN_268],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_263], ExecError> {
+) -> Result<[G; OUT_268], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
@@ -24996,31 +25184,31 @@ fn aiur_fn_263(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_263] = [__v_10, __v_14];
-            record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_268] = [__v_10, __v_14];
+            record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
             match __v_12.as_canonical_u64() {
               1u64 => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
                 let __v_16: G = G::from_u64(1);
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
-                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_18, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
-                let __ret: [G; OUT_263] = [__v_16, __v_19];
-                record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_268] = [__v_16, __v_19];
+                record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -25029,8 +25217,8 @@ fn aiur_fn_263(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_263] = [__v_14, __v_18];
-                record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_268] = [__v_14, __v_18];
+                record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -25049,33 +25237,33 @@ fn aiur_fn_263(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_263] = [__v_10, __v_14];
-                record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_268] = [__v_10, __v_14];
+                record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = __r_arr[1];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_14: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_125] = { let __args: [G; IN_125] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
                     let __v_17: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                     let __v_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_19, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_20: G = __r_arr[0];
-                    let __ret: [G; OUT_263] = [__v_16, __v_20];
-                    record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_268] = [__v_16, __v_20];
+                    record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -25084,8 +25272,8 @@ fn aiur_fn_263(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_263] = [__v_14, __v_18];
-                    record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_268] = [__v_14, __v_18];
+                    record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -25093,11 +25281,11 @@ fn aiur_fn_263(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_263] = [__v_8, __v_9];
-            record.function_queries[263].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_268] = [__v_8, __v_9];
+            record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -25106,15 +25294,15 @@ fn aiur_fn_263(
   })
 }
 
-const INPUT_SIZE_264: usize = 3;
-const IN_264: usize = 3;
-const OUT_264: usize = 2;
-fn aiur_fn_264(
-  inp: [G; IN_264],
+const INPUT_SIZE_269: usize = 3;
+const IN_269: usize = 3;
+const OUT_269: usize = 2;
+fn aiur_fn_269(
+  inp: [G; IN_269],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_264], ExecError> {
+) -> Result<[G; OUT_269], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25128,40 +25316,40 @@ fn aiur_fn_264(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_264] = [__v_5, __v_9];
-        record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_269] = [__v_5, __v_9];
+        record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[256].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[256].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[256].bump_multiplicity(__i); } let __ret: [G; OUT_256] = unsafe { *(record.function_queries[256].output_at(__i).as_ptr() as *const [G; OUT_256]) }; __ret }, _ => aiur_fn_256(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = [__v_0, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[261].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[261].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[261].bump_multiplicity(__i); } let __ret: [G; OUT_261] = unsafe { *(record.function_queries[261].output_at(__i).as_ptr() as *const [G; OUT_261]) }; __ret }, _ => aiur_fn_261(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
                     let __v_15: G = G::from_u64(2);
-                    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __ret: [G; OUT_264] = [__v_17, __v_18];
-                    record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_269] = [__v_17, __v_18];
+                    record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -25170,8 +25358,8 @@ fn aiur_fn_264(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_264] = [__v_15, __v_19];
-                    record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_269] = [__v_15, __v_19];
+                    record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -25182,23 +25370,23 @@ fn aiur_fn_264(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_264] = [__v_13, __v_17];
-                record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_269] = [__v_13, __v_17];
+                record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[265].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[265].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => aiur_fn_265(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_0, __v_6, __v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_264] = [__v_13, __v_14];
-                record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_269] = [__v_13, __v_14];
+                record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -25207,8 +25395,8 @@ fn aiur_fn_264(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_264] = [__v_13, __v_17];
-                record.function_queries[264].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_269] = [__v_13, __v_17];
+                record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -25219,43 +25407,43 @@ fn aiur_fn_264(
   })
 }
 
-const INPUT_SIZE_265: usize = 4;
-const IN_265: usize = 4;
-const OUT_265: usize = 2;
-fn aiur_fn_265(
-  inp: [G; IN_265],
+const INPUT_SIZE_270: usize = 4;
+const IN_270: usize = 4;
+const OUT_270: usize = 2;
+fn aiur_fn_270(
+  inp: [G; IN_270],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_265], ExecError> {
+) -> Result<[G; OUT_270], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = (__v_7 + __v_9);
     let __v_11: G = G::from_u64(1);
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = (__v_11 - __v_12);
     let __v_14: G = G::from_u64(1);
-    let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     let __v_18: G = (__v_14 - __v_17);
     let __v_19: G = (__v_13 * __v_18);
@@ -25268,24 +25456,24 @@ fn aiur_fn_265(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_265] = [__v_22, __v_26];
-        record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_270] = [__v_22, __v_26];
+        record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_3, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_3, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = [__v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[265].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[265].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[265].bump_multiplicity(__i); } let __ret: [G; OUT_265] = unsafe { *(record.function_queries[265].output_at(__i).as_ptr() as *const [G; OUT_265]) }; __ret }, _ => aiur_fn_265(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
             let __v_25: G = __r_arr[1];
             match __v_24.as_canonical_u64() {
               1u64 => {
                 let __v_26: G = G::from_u64(2);
-                let __ret: [G; OUT_265] = [__v_26, __v_25];
-                record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_270] = [__v_26, __v_25];
+                record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -25294,18 +25482,18 @@ fn aiur_fn_265(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_265] = [__v_26, __v_30];
-                record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_270] = [__v_26, __v_30];
+                record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_24: G = G::from_u64(2);
-            let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[266].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[266].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[266].bump_multiplicity(__i); } let __ret: [G; OUT_266] = unsafe { *(record.function_queries[266].output_at(__i).as_ptr() as *const [G; OUT_266]) }; __ret }, _ => aiur_fn_266(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_0, __v_1, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_265] = [__v_24, __v_25];
-            record.function_queries[265].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_270] = [__v_24, __v_25];
+            record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -25314,15 +25502,15 @@ fn aiur_fn_265(
   })
 }
 
-const INPUT_SIZE_266: usize = 4;
-const IN_266: usize = 4;
-const OUT_266: usize = 1;
-fn aiur_fn_266(
-  inp: [G; IN_266],
+const INPUT_SIZE_271: usize = 4;
+const IN_271: usize = 4;
+const OUT_271: usize = 1;
+fn aiur_fn_271(
+  inp: [G; IN_271],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_266], ExecError> {
+) -> Result<[G; OUT_271], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25338,27 +25526,27 @@ fn aiur_fn_266(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
-    let __ret: [G; OUT_266] = [__v_17];
-    record.function_queries[266].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_271] = [__v_17];
+    record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_267: usize = 10;
-const IN_267: usize = 10;
-const OUT_267: usize = 8;
-fn aiur_fn_267(
-  inp: [G; IN_267],
+const INPUT_SIZE_272: usize = 10;
+const IN_272: usize = 10;
+const OUT_272: usize = 8;
+fn aiur_fn_272(
+  inp: [G; IN_272],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_267], ExecError> {
+) -> Result<[G; OUT_272], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25372,8 +25560,8 @@ fn aiur_fn_267(
     let __v_9: G = inp[9];
     match __v_9.as_canonical_u64() {
       8u64 => {
-        let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-        record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_272] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -25383,15 +25571,15 @@ fn aiur_fn_267(
         let __v_12: G = __loaded[2];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_267] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-            record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_272] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+            record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(1);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25400,13 +25588,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
                 let __v_13: G = G::from_u64(2);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25415,13 +25603,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               2u64 => {
                 let __v_13: G = G::from_u64(3);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_2, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25430,13 +25618,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               3u64 => {
                 let __v_13: G = G::from_u64(4);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_2, __v_3, __v_11, __v_5, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25445,13 +25633,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               4u64 => {
                 let __v_13: G = G::from_u64(5);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25460,13 +25648,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               5u64 => {
                 let __v_13: G = G::from_u64(6);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_11, __v_7, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25475,13 +25663,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               6u64 => {
                 let __v_13: G = G::from_u64(7);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_11, __v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25490,13 +25678,13 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_13: G = G::from_u64(8);
-                let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25505,8 +25693,8 @@ fn aiur_fn_267(
                 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_267] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
-                record.function_queries[267].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_272] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21];
+                record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -25520,22 +25708,22 @@ fn aiur_fn_267(
   })
 }
 
-const INPUT_SIZE_268: usize = 2;
-const IN_268: usize = 2;
-const OUT_268: usize = 1;
-fn aiur_fn_268(
-  inp: [G; IN_268],
+const INPUT_SIZE_273: usize = 2;
+const IN_273: usize = 2;
+const OUT_273: usize = 1;
+fn aiur_fn_273(
+  inp: [G; IN_273],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_268], ExecError> {
+) -> Result<[G; OUT_273], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_268] = [__v_0];
-        record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_273] = [__v_0];
+        record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -25548,17 +25736,17 @@ fn aiur_fn_268(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_268] = [__v_7];
-            record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_273] = [__v_7];
+            record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_5: G = G::from_u64(1);
             let __v_6: G = (__v_1 - __v_5);
-            let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_268] = [__v_7];
-            record.function_queries[268].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_273] = [__v_7];
+            record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -25570,15 +25758,15 @@ fn aiur_fn_268(
   })
 }
 
-const INPUT_SIZE_269: usize = 1;
-const IN_269: usize = 1;
-const OUT_269: usize = 1;
-fn aiur_fn_269(
-  inp: [G; IN_269],
+const INPUT_SIZE_274: usize = 1;
+const IN_274: usize = 1;
+const OUT_274: usize = 1;
+fn aiur_fn_274(
+  inp: [G; IN_274],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_269], ExecError> {
+) -> Result<[G; OUT_274], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -25590,7 +25778,7 @@ fn aiur_fn_269(
     let __v_7: G = G::from_u64(0);
     let __v_8: G = G::from_u64(0);
     let __v_9: G = G::from_u64(0);
-    let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__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];
@@ -25600,7 +25788,7 @@ fn aiur_fn_269(
     let __v_16: G = __r_arr[6];
     let __v_17: G = __r_arr[7];
     let __v_18: G = G::from_u64(8);
-    let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[268].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[268].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[268].bump_multiplicity(__i); } let __ret: [G; OUT_268] = unsafe { *(record.function_queries[268].output_at(__i).as_ptr() as *const [G; OUT_268]) }; __ret }, _ => aiur_fn_268(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_0, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_20: G = __loaded[0];
@@ -25614,7 +25802,7 @@ fn aiur_fn_269(
     break '__mc_0 [__v_25];
   },
   _ => {
-    let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[274].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => aiur_fn_274(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
     break '__mc_0 [__v_23];
   },
@@ -25641,8 +25829,8 @@ fn aiur_fn_269(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_269] = [__v_37];
-            record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_274] = [__v_37];
+            record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -25651,8 +25839,8 @@ fn aiur_fn_269(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_269] = [__v_39];
-            record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_274] = [__v_39];
+            record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -25663,23 +25851,23 @@ fn aiur_fn_269(
       _ => {
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_269] = [__v_35];
-        record.function_queries[269].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_274] = [__v_35];
+        record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_270: usize = 1;
-const IN_270: usize = 1;
-const OUT_270: usize = 1;
-fn aiur_fn_270(
-  inp: [G; IN_270],
+const INPUT_SIZE_275: usize = 1;
+const IN_275: usize = 1;
+const OUT_275: usize = 1;
+fn aiur_fn_275(
+  inp: [G; IN_275],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_270], ExecError> {
+) -> Result<[G; OUT_275], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 9 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 9] = __args[..9].try_into().unwrap(); __arr };
@@ -25697,40 +25885,40 @@ fn aiur_fn_270(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_12];
-        record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_275] = [__v_12];
+        record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_13];
-        record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_275] = [__v_13];
+        record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_10: G = G::from_u64(2);
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_13];
-        record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_275] = [__v_13];
+        record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_10: G = G::from_u64(3);
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_13];
-        record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_275] = [__v_13];
+        record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
@@ -25739,8 +25927,8 @@ fn aiur_fn_270(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_270] = [__v_13];
-        record.function_queries[270].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_275] = [__v_13];
+        record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -25750,15 +25938,15 @@ fn aiur_fn_270(
   })
 }
 
-const INPUT_SIZE_271: usize = 2;
-const IN_271: usize = 2;
-const OUT_271: usize = 1;
-fn aiur_fn_271(
-  inp: [G; IN_271],
+const INPUT_SIZE_276: usize = 2;
+const IN_276: usize = 2;
+const OUT_276: usize = 1;
+fn aiur_fn_276(
+  inp: [G; IN_276],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_271], ExecError> {
+) -> Result<[G; OUT_276], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25778,23 +25966,23 @@ fn aiur_fn_271(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_14];
-        record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_276] = [__v_14];
+        record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_270] = { let __args: [G; IN_270] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_271] = [__v_17];
-        record.function_queries[271].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_276] = [__v_17];
+        record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -25804,15 +25992,15 @@ fn aiur_fn_271(
   })
 }
 
-const INPUT_SIZE_272: usize = 5;
-const IN_272: usize = 5;
-const OUT_272: usize = 1;
-fn aiur_fn_272(
-  inp: [G; IN_272],
+const INPUT_SIZE_277: usize = 5;
+const IN_277: usize = 5;
+const OUT_277: usize = 1;
+fn aiur_fn_277(
+  inp: [G; IN_277],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_272], ExecError> {
+) -> Result<[G; OUT_277], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -25842,15 +26030,15 @@ fn aiur_fn_272(
       0u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_270] = { let __args: [G; IN_270] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[270].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[270].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[270].bump_multiplicity(__i); } let __ret: [G; OUT_270] = unsafe { *(record.function_queries[270].output_at(__i).as_ptr() as *const [G; OUT_270]) }; __ret }, _ => aiur_fn_270(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_28];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_28];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -25859,139 +26047,139 @@ fn aiur_fn_272(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_26];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_26];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_28];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_28];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[271].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[271].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[271].bump_multiplicity(__i); } let __ret: [G; OUT_271] = unsafe { *(record.function_queries[271].output_at(__i).as_ptr() as *const [G; OUT_271]) }; __ret }, _ => aiur_fn_271(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_28];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_28];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_17] = { let __args: [G; IN_17] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_22, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_28];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_28];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[284].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => aiur_fn_284(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } };
         let __v_26: G = G::from_u64(7);
         let __v_27: G = G::from_u64(1);
         let __v_28: G = G::from_u64(0);
         let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_25, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_29];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_29];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[284].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => aiur_fn_284(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[274].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => aiur_fn_274(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
         let __v_27: G = G::from_u64(7);
         let __v_28: G = G::from_u64(0);
         let __v_29: G = G::from_u64(0);
         let __v_30: G = { let __values: [G; 4] = [__v_27, __v_28, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_30];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_30];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_23: G = G::from_u64(3);
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_27];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_27];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_23: G = G::from_u64(4);
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_27];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_27];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       9u64 => {
         let __v_23: G = G::from_u64(5);
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_11, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_12, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_27];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_27];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       10u64 => {
         let __v_23: G = G::from_u64(6);
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_14, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_11, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_12, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_16, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_13, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_272] = [__v_27];
-        record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_277] = [__v_27];
+        record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       11u64 => {
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_25: G = __loaded[0];
@@ -25999,10 +26187,10 @@ fn aiur_fn_272(
         let __v_27: G = __loaded[2];
         match __v_25.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_26, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_272] = [__v_28];
-            record.function_queries[272].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_277] = [__v_28];
+            record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -26017,15 +26205,15 @@ fn aiur_fn_272(
   })
 }
 
-const INPUT_SIZE_273: usize = 17;
-const IN_273: usize = 17;
-const OUT_273: usize = 12;
-fn aiur_fn_273(
-  inp: [G; IN_273],
+const INPUT_SIZE_278: usize = 17;
+const IN_278: usize = 17;
+const OUT_278: usize = 12;
+fn aiur_fn_278(
+  inp: [G; IN_278],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_273], ExecError> {
+) -> Result<[G; OUT_278], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26046,9 +26234,9 @@ fn aiur_fn_273(
     let __v_16: G = inp[16];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_10, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
@@ -26056,8 +26244,8 @@ fn aiur_fn_273(
           0u64 => {
             let __v_20: G = G::from_u64(1);
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
-            record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_278] = [__v_20, __v_19, __v_17, __v_18, __v_1, __v_16, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
@@ -26075,15 +26263,15 @@ fn aiur_fn_273(
             let __v_20: G = __mc_out___mc_0[0];
             let __v_21: G = G::from_u64(3);
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_273] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
-            record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_278] = [__v_21, __v_19, __v_17, __v_18, __v_20, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22];
+            record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_20: G = G::from_u64(2);
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_273] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
-            record.function_queries[273].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_278] = [__v_20, __v_19, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21];
+            record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -26095,15 +26283,15 @@ fn aiur_fn_273(
   })
 }
 
-const INPUT_SIZE_274: usize = 14;
-const IN_274: usize = 14;
-const OUT_274: usize = 12;
-fn aiur_fn_274(
-  inp: [G; IN_274],
+const INPUT_SIZE_279: usize = 14;
+const IN_279: usize = 14;
+const OUT_279: usize = 12;
+fn aiur_fn_279(
+  inp: [G; IN_279],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_274], ExecError> {
+) -> Result<[G; OUT_279], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26121,29 +26309,29 @@ fn aiur_fn_274(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(0);
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_274] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
-        record.function_queries[274].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_279] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        record.function_queries[279].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_275: usize = 14;
-const IN_275: usize = 14;
-const OUT_275: usize = 12;
-fn aiur_fn_275(
-  inp: [G; IN_275],
+const INPUT_SIZE_280: usize = 14;
+const IN_280: usize = 14;
+const OUT_280: usize = 12;
+fn aiur_fn_280(
+  inp: [G; IN_280],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_275], ExecError> {
+) -> Result<[G; OUT_280], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26161,29 +26349,29 @@ fn aiur_fn_275(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(4);
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = G::from_u64(0);
-        let __ret: [G; OUT_275] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
-        record.function_queries[275].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_280] = [__v_15, __v_16, __v_14, __v_0, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17];
+        record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_276: usize = 1;
-const IN_276: usize = 1;
-const OUT_276: usize = 1;
-fn aiur_fn_276(
-  inp: [G; IN_276],
+const INPUT_SIZE_281: usize = 1;
+const IN_281: usize = 1;
+const OUT_281: usize = 1;
+fn aiur_fn_281(
+  inp: [G; IN_281],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_276], ExecError> {
+) -> Result<[G; OUT_281], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
@@ -26226,17 +26414,17 @@ fn aiur_fn_276(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_37: G = G::from_u64(0);
-        let __ret: [G; OUT_276] = [__v_37];
-        record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_281] = [__v_37];
+        record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__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_276] = [__v_39];
-        record.function_queries[276].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_281] = [__v_39];
+        record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -26246,15 +26434,15 @@ fn aiur_fn_276(
   })
 }
 
-const INPUT_SIZE_277: usize = 2;
-const IN_277: usize = 2;
-const OUT_277: usize = 34;
-fn aiur_fn_277(
-  inp: [G; IN_277],
+const INPUT_SIZE_282: usize = 2;
+const IN_282: usize = 2;
+const OUT_282: usize = 34;
+fn aiur_fn_282(
+  inp: [G; IN_282],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_277], ExecError> {
+) -> Result<[G; OUT_282], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26299,14 +26487,14 @@ fn aiur_fn_277(
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_277] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
-            record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_282] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36];
+            record.function_queries[282].finish(&inp[..], &__ret[..], !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_277] = { let __args: [G; IN_277] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_37, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__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];
@@ -26341,8 +26529,8 @@ fn aiur_fn_277(
             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_277] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73];
-            record.function_queries[277].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_282] = [__v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73];
+            record.function_queries[282].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -26354,15 +26542,15 @@ fn aiur_fn_277(
   })
 }
 
-const INPUT_SIZE_278: usize = 33;
-const IN_278: usize = 33;
-const OUT_278: usize = 12;
-fn aiur_fn_278(
-  inp: [G; IN_278],
+const INPUT_SIZE_283: usize = 33;
+const IN_283: usize = 33;
+const OUT_283: usize = 12;
+fn aiur_fn_283(
+  inp: [G; IN_283],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_278], ExecError> {
+) -> Result<[G; OUT_283], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26399,7 +26587,7 @@ fn aiur_fn_278(
     let __v_32: G = inp[32];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_25, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_33: G = __r_arr[0];
         let __v_34: G = G::from_u64(5);
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
@@ -26408,26 +26596,26 @@ fn aiur_fn_278(
         let __v_36: G = __r_arr[0];
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[276].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[276].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[276].bump_multiplicity(__i); } let __ret: [G; OUT_276] = unsafe { *(record.function_queries[276].output_at(__i).as_ptr() as *const [G; OUT_276]) }; __ret }, _ => aiur_fn_276(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_26]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __v_39: G = G::from_u64(0);
-        let __ret: [G; OUT_278] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
-        record.function_queries[278].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_283] = [__v_34, __v_35, __v_33, __v_36, __v_37, __v_38, __v_0, __v_27, __v_28, __v_39, __v_39, __v_39];
+        record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_279: usize = 40;
-const IN_279: usize = 40;
-const OUT_279: usize = 12;
-fn aiur_fn_279(
-  inp: [G; IN_279],
+const INPUT_SIZE_284: usize = 40;
+const IN_284: usize = 40;
+const OUT_284: usize = 12;
+fn aiur_fn_284(
+  inp: [G; IN_284],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_279], ExecError> {
+) -> Result<[G; OUT_284], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26471,7 +26659,7 @@ fn aiur_fn_279(
     let __v_39: G = inp[39];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_33, __v_36, __v_37, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
         let __v_41: G = G::from_u64(6);
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
@@ -26483,23 +26671,23 @@ fn aiur_fn_279(
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_45: G = __r_arr[0];
         let __v_46: G = G::from_u64(0);
-        let __ret: [G; OUT_279] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
-        record.function_queries[279].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_284] = [__v_41, __v_42, __v_40, __v_34, __v_35, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46];
+        record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_280: usize = 6;
-const IN_280: usize = 6;
-const OUT_280: usize = 1;
-fn aiur_fn_280(
-  inp: [G; IN_280],
+const INPUT_SIZE_285: usize = 6;
+const IN_285: usize = 6;
+const OUT_285: usize = 1;
+fn aiur_fn_285(
+  inp: [G; IN_285],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_280], ExecError> {
+) -> Result<[G; OUT_285], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26524,25 +26712,25 @@ fn aiur_fn_280(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_280] = [__v_19];
-        record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_285] = [__v_19];
+        record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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_17] = { let __args: [G; IN_17] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__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_280] = { let __args: [G; IN_280] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_280] = [__v_23];
-            record.function_queries[280].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_285] = [__v_23];
+            record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -26554,15 +26742,15 @@ fn aiur_fn_280(
   })
 }
 
-const INPUT_SIZE_281: usize = 50;
-const IN_281: usize = 50;
-const OUT_281: usize = 12;
-fn aiur_fn_281(
-  inp: [G; IN_281],
+const INPUT_SIZE_286: usize = 50;
+const IN_286: usize = 50;
+const OUT_286: usize = 12;
+fn aiur_fn_286(
+  inp: [G; IN_286],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_281], ExecError> {
+) -> Result<[G; OUT_286], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26616,10 +26804,10 @@ fn aiur_fn_281(
     let __v_49: G = inp[49];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[272].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[272].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[272].bump_multiplicity(__i); } let __ret: [G; OUT_272] = unsafe { *(record.function_queries[272].output_at(__i).as_ptr() as *const [G; OUT_272]) }; __ret }, _ => aiur_fn_272(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_42, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__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_280] = { let __args: [G; IN_280] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_43, __v_46, __v_47, __v_48, __v_49, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } };
         let __v_52: G = __r_arr[0];
         let __v_53: G = G::from_u64(7);
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
@@ -26632,23 +26820,23 @@ fn aiur_fn_281(
         let __v_57: G = __r_arr[0];
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_58: G = __r_arr[0];
-        let __ret: [G; OUT_281] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
-        record.function_queries[281].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_286] = [__v_53, __v_54, __v_50, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_44, __v_45];
+        record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_282: usize = 1;
-const IN_282: usize = 1;
-const OUT_282: usize = 48;
-fn aiur_fn_282(
-  inp: [G; IN_282],
+const INPUT_SIZE_287: usize = 1;
+const IN_287: usize = 1;
+const OUT_287: usize = 48;
+fn aiur_fn_287(
+  inp: [G; IN_287],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_282], ExecError> {
+) -> Result<[G; OUT_287], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -26692,7 +26880,7 @@ fn aiur_fn_282(
     let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
     let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[21].bump_multiplicity(__i); } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[119].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[119].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[119].bump_multiplicity(__i); } let __ret: [G; OUT_119] = unsafe { *(record.function_queries[119].output_at(__i).as_ptr() as *const [G; OUT_119]) }; __ret }, _ => aiur_fn_119(__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];
@@ -26757,21 +26945,21 @@ fn aiur_fn_282(
     if (__v_89 != __v_91) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64(), msg: Some("trailing bytes after constant on ch 2".to_string()) });
     }
-    let __ret: [G; OUT_282] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_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[282].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_287] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_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[287].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_283: usize = 1;
-const IN_283: usize = 1;
-const OUT_283: usize = 1;
-fn aiur_fn_283(
-  inp: [G; IN_283],
+const INPUT_SIZE_288: usize = 1;
+const IN_288: usize = 1;
+const OUT_288: usize = 1;
+fn aiur_fn_288(
+  inp: [G; IN_288],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_283], ExecError> {
+) -> Result<[G; OUT_288], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -26820,8 +27008,8 @@ fn aiur_fn_283(
     let __v_40: G = __loaded[2];
     match __v_38.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_283] = [__v_39];
-        record.function_queries[283].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_288] = [__v_39];
+        record.function_queries[288].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -26831,15 +27019,15 @@ fn aiur_fn_283(
   })
 }
 
-const INPUT_SIZE_284: usize = 1;
-const IN_284: usize = 1;
-const OUT_284: usize = 1;
-fn aiur_fn_284(
-  inp: [G; IN_284],
+const INPUT_SIZE_289: usize = 1;
+const IN_289: usize = 1;
+const OUT_289: usize = 1;
+fn aiur_fn_289(
+  inp: [G; IN_289],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_284], ExecError> {
+) -> Result<[G; OUT_289], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -26883,43 +27071,43 @@ fn aiur_fn_284(
     let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
     let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__v_37, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[21].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[21].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[21].bump_multiplicity(__i); } let __ret: [G; OUT_21] = unsafe { *(record.function_queries[21].output_at(__i).as_ptr() as *const [G; OUT_21]) }; __ret }, _ => aiur_fn_21(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_284] = [__v_37];
-    record.function_queries[284].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_289] = [__v_37];
+    record.function_queries[289].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_285: usize = 2;
-const IN_285: usize = 2;
-const OUT_285: usize = 1;
-fn aiur_fn_285(
-  inp: [G; IN_285],
+const INPUT_SIZE_290: usize = 2;
+const IN_290: usize = 2;
+const OUT_290: usize = 1;
+fn aiur_fn_290(
+  inp: [G; IN_290],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_285], ExecError> {
+) -> Result<[G; OUT_290], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       2u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_285] = [__v_2];
-        record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_290] = [__v_2];
+        record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_285] = [__v_2];
-            record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_290] = [__v_2];
+            record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_285] = [__v_2];
-            record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_290] = [__v_2];
+            record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -26928,14 +27116,14 @@ fn aiur_fn_285(
         match __v_1.as_canonical_u64() {
           1u64 => {
             let __v_2: G = G::from_u64(0);
-            let __ret: [G; OUT_285] = [__v_2];
-            record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_290] = [__v_2];
+            record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_2: G = G::from_u64(1);
-            let __ret: [G; OUT_285] = [__v_2];
-            record.function_queries[285].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_290] = [__v_2];
+            record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -26947,15 +27135,15 @@ fn aiur_fn_285(
   })
 }
 
-const INPUT_SIZE_286: usize = 14;
-const IN_286: usize = 14;
-const OUT_286: usize = 1;
-fn aiur_fn_286(
-  inp: [G; IN_286],
+const INPUT_SIZE_291: usize = 14;
+const IN_291: usize = 14;
+const OUT_291: usize = 1;
+fn aiur_fn_291(
+  inp: [G; IN_291],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_286], ExecError> {
+) -> Result<[G; OUT_291], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -26973,22 +27161,22 @@ fn aiur_fn_286(
     let __v_13: G = inp[13];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         match __v_14.as_canonical_u64() {
           0u64 => {
             let __v_15: G = G::from_u64(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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_286] = [__v_17];
-            record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_291] = [__v_17];
+            record.function_queries[291].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_286] = [__v_15];
-            record.function_queries[286].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_291] = [__v_15];
+            record.function_queries[291].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -26997,18 +27185,18 @@ fn aiur_fn_286(
   })
 }
 
-const INPUT_SIZE_287: usize = 1;
-const IN_287: usize = 1;
-const OUT_287: usize = 1;
-fn aiur_fn_287(
-  inp: [G; IN_287],
+const INPUT_SIZE_292: usize = 1;
+const IN_292: usize = 1;
+const OUT_292: usize = 1;
+fn aiur_fn_292(
+  inp: [G; IN_292],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_287], ExecError> {
+) -> Result<[G; OUT_292], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -27061,11 +27249,11 @@ fn aiur_fn_287(
       _ => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = true; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   _ => {
-    let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[285].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[285].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[285].bump_multiplicity(__i); } let __ret: [G; OUT_285] = unsafe { *(record.function_queries[285].output_at(__i).as_ptr() as *const [G; OUT_285]) }; __ret }, _ => aiur_fn_285(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
     let __v_50: G = __r_arr[0];
     match __v_50.as_canonical_u64() {
       0u64 => {
@@ -27087,7 +27275,7 @@ fn aiur_fn_287(
 }
  };
             let __v_50: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_46, __v_47, __v_50, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__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];
@@ -27101,15 +27289,15 @@ fn aiur_fn_287(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_287] = [__v_63];
-            record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_292] = [__v_63];
+            record.function_queries[292].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = [__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; let __hit = record.function_queries[274].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[274].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[274].bump_multiplicity(__i); } let __ret: [G; OUT_274] = unsafe { *(record.function_queries[274].output_at(__i).as_ptr() as *const [G; OUT_274]) }; __ret }, _ => aiur_fn_274(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__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; let __hit = record.function_queries[279].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[279].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => aiur_fn_279(__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];
@@ -27123,15 +27311,15 @@ fn aiur_fn_287(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_287] = [__v_64];
-            record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_292] = [__v_64];
+            record.function_queries[292].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = [__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; let __hit = record.function_queries[275].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[275].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[275].bump_multiplicity(__i); } let __ret: [G; OUT_275] = unsafe { *(record.function_queries[275].output_at(__i).as_ptr() as *const [G; OUT_275]) }; __ret }, _ => aiur_fn_275(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = [__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; let __hit = record.function_queries[280].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[280].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[280].bump_multiplicity(__i); } let __ret: [G; OUT_280] = unsafe { *(record.function_queries[280].output_at(__i).as_ptr() as *const [G; OUT_280]) }; __ret }, _ => aiur_fn_280(__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];
@@ -27145,17 +27333,17 @@ fn aiur_fn_287(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_287] = [__v_64];
-            record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_292] = [__v_64];
+            record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           7u64 => {
             match __v_2.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[288].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[288].bump_multiplicity(__i); } let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __ret: [G; OUT_287] = [__v_49];
-                record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_292] = [__v_49];
+                record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -27165,10 +27353,10 @@ fn aiur_fn_287(
               _ => {
                 let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __ret: [G; OUT_287] = [__v_50];
-                record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_292] = [__v_50];
+                record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -27180,10 +27368,10 @@ fn aiur_fn_287(
                 let __v_49: G = __r_arr[0];
                 let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_18, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __ret: [G; OUT_287] = [__v_51];
-                record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_292] = [__v_51];
+                record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -27193,10 +27381,10 @@ fn aiur_fn_287(
               _ => {
                 let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_10, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __ret: [G; OUT_287] = [__v_50];
-                record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_292] = [__v_50];
+                record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -27208,7 +27396,7 @@ fn aiur_fn_287(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_281] = { let __args: [G; IN_281] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_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; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__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];
@@ -27222,8 +27410,8 @@ fn aiur_fn_287(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_287] = [__v_67];
-            record.function_queries[287].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_292] = [__v_67];
+            record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -27235,15 +27423,15 @@ fn aiur_fn_287(
   })
 }
 
-const INPUT_SIZE_288: usize = 10;
-const IN_288: usize = 10;
-const OUT_288: usize = 1;
-fn aiur_fn_288(
-  inp: [G; IN_288],
+const INPUT_SIZE_293: usize = 10;
+const IN_293: usize = 10;
+const OUT_293: usize = 1;
+fn aiur_fn_293(
+  inp: [G; IN_293],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_288], ExecError> {
+) -> Result<[G; OUT_293], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -27255,7 +27443,7 @@ fn aiur_fn_288(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -27308,7 +27496,7 @@ fn aiur_fn_288(
       _ => {
         match __v_10.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_11, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[784].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i); } let __ret: [G; OUT_784] = unsafe { *(record.function_queries[784].output_at(__i).as_ptr() as *const [G; OUT_784]) }; __ret }, _ => aiur_fn_784(__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];
@@ -27356,11 +27544,11 @@ fn aiur_fn_288(
             let __v_102: G = __r_arr[44];
             match __v_58.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_0]; let __cu = true; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = [__v_0]; let __cu = true; let __hit = record.function_queries[288].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_288] = unsafe { *(record.function_queries[288].output_at(__i).as_ptr() as *const [G; OUT_288]) }; __ret }, _ => aiur_fn_288(__args, record, io_buffer, __cu)? } };
                 let __v_103: G = __r_arr[0];
-                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__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_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = [__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_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[291].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[291].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[291].bump_multiplicity(__i); } let __ret: [G; OUT_291] = unsafe { *(record.function_queries[291].output_at(__i).as_ptr() as *const [G; OUT_291]) }; __ret }, _ => aiur_fn_291(__args, record, io_buffer, __cu)? } };
                 let __v_104: G = __r_arr[0];
-                let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[273].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[273].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[273].bump_multiplicity(__i); } let __ret: [G; OUT_273] = unsafe { *(record.function_queries[273].output_at(__i).as_ptr() as *const [G; OUT_273]) }; __ret }, _ => aiur_fn_273(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_55, __v_56, __v_104, __v_57, __v_103]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } };
                 let __v_105: G = __r_arr[0];
                 let __v_106: G = __r_arr[1];
                 let __v_107: G = __r_arr[2];
@@ -27374,8 +27562,8 @@ fn aiur_fn_288(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_288] = [__v_117];
-                record.function_queries[288].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_293] = [__v_117];
+                record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -27392,19 +27580,19 @@ fn aiur_fn_288(
   })
 }
 
-const INPUT_SIZE_289: usize = 2;
-const IN_289: usize = 2;
-const OUT_289: usize = 1;
-fn aiur_fn_289(
-  inp: [G; IN_289],
+const INPUT_SIZE_294: usize = 2;
+const IN_294: usize = 2;
+const OUT_294: usize = 1;
+fn aiur_fn_294(
+  inp: [G; IN_294],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_289], ExecError> {
+) -> Result<[G; OUT_294], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -27457,7 +27645,7 @@ fn aiur_fn_289(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__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];
@@ -27505,9 +27693,9 @@ fn aiur_fn_289(
             let __v_94: G = __r_arr[44];
             match __v_50.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
                 let __v_95: G = __r_arr[0];
-                let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[278].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[278].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[278].bump_multiplicity(__i); } let __ret: [G; OUT_278] = unsafe { *(record.function_queries[278].output_at(__i).as_ptr() as *const [G; OUT_278]) }; __ret }, _ => aiur_fn_278(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[283].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[283].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[283].bump_multiplicity(__i); } let __ret: [G; OUT_283] = unsafe { *(record.function_queries[283].output_at(__i).as_ptr() as *const [G; OUT_283]) }; __ret }, _ => aiur_fn_283(__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];
@@ -27521,8 +27709,8 @@ fn aiur_fn_289(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_289] = [__v_108];
-                record.function_queries[289].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_294] = [__v_108];
+                record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -27539,20 +27727,20 @@ fn aiur_fn_289(
   })
 }
 
-const INPUT_SIZE_290: usize = 3;
-const IN_290: usize = 3;
-const OUT_290: usize = 1;
-fn aiur_fn_290(
-  inp: [G; IN_290],
+const INPUT_SIZE_295: usize = 3;
+const IN_295: usize = 3;
+const OUT_295: usize = 1;
+fn aiur_fn_295(
+  inp: [G; IN_295],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_290], ExecError> {
+) -> Result<[G; OUT_295], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -27605,7 +27793,7 @@ fn aiur_fn_290(
       _ => {
         match __v_3.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__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];
@@ -27655,7 +27843,7 @@ fn aiur_fn_290(
               1u64 => {
                 match __v_52.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = [__v_78, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[277].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[277].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[277].bump_multiplicity(__i); } let __ret: [G; OUT_277] = unsafe { *(record.function_queries[277].output_at(__i).as_ptr() as *const [G; OUT_277]) }; __ret }, _ => aiur_fn_277(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_78, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__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];
@@ -27690,9 +27878,9 @@ fn aiur_fn_290(
                     let __v_127: G = __r_arr[31];
                     let __v_128: G = __r_arr[32];
                     let __v_129: G = __r_arr[33];
-                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
                     let __v_130: G = __r_arr[0];
-                    let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[279].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[279].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[279].bump_multiplicity(__i); } let __ret: [G; OUT_279] = unsafe { *(record.function_queries[279].output_at(__i).as_ptr() as *const [G; OUT_279]) }; __ret }, _ => aiur_fn_279(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = [__v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_0, __v_1, __v_48, __v_49, __v_130, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[284].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[284].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[284].bump_multiplicity(__i); } let __ret: [G; OUT_284] = unsafe { *(record.function_queries[284].output_at(__i).as_ptr() as *const [G; OUT_284]) }; __ret }, _ => aiur_fn_284(__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];
@@ -27706,8 +27894,8 @@ fn aiur_fn_290(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_290] = [__v_143];
-                    record.function_queries[290].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_295] = [__v_143];
+                    record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -27726,19 +27914,19 @@ fn aiur_fn_290(
   })
 }
 
-const INPUT_SIZE_291: usize = 2;
-const IN_291: usize = 2;
-const OUT_291: usize = 1;
-fn aiur_fn_291(
-  inp: [G; IN_291],
+const INPUT_SIZE_296: usize = 2;
+const IN_296: usize = 2;
+const OUT_296: usize = 1;
+fn aiur_fn_296(
+  inp: [G; IN_296],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_291], ExecError> {
+) -> Result<[G; OUT_296], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -27791,7 +27979,7 @@ fn aiur_fn_291(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__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];
@@ -27839,9 +28027,9 @@ fn aiur_fn_291(
             let __v_94: G = __r_arr[44];
             match __v_50.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
                 let __v_95: G = __r_arr[0];
-                let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[281].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[281].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[281].bump_multiplicity(__i); } let __ret: [G; OUT_281] = unsafe { *(record.function_queries[281].output_at(__i).as_ptr() as *const [G; OUT_281]) }; __ret }, _ => aiur_fn_281(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_0, __v_1, __v_47, __v_48, __v_95, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[286].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[286].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[286].bump_multiplicity(__i); } let __ret: [G; OUT_286] = unsafe { *(record.function_queries[286].output_at(__i).as_ptr() as *const [G; OUT_286]) }; __ret }, _ => aiur_fn_286(__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];
@@ -27855,8 +28043,8 @@ fn aiur_fn_291(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_291] = [__v_108];
-                record.function_queries[291].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_296] = [__v_108];
+                record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -27873,15 +28061,15 @@ fn aiur_fn_291(
   })
 }
 
-const INPUT_SIZE_292: usize = 2;
-const IN_292: usize = 2;
-const OUT_292: usize = 45;
-fn aiur_fn_292(
-  inp: [G; IN_292],
+const INPUT_SIZE_297: usize = 2;
+const IN_297: usize = 2;
+const OUT_297: usize = 45;
+fn aiur_fn_297(
+  inp: [G; IN_297],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_292], ExecError> {
+) -> Result<[G; OUT_297], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -27937,14 +28125,14 @@ fn aiur_fn_292(
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_292] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
-            record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_297] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47];
+            record.function_queries[297].finish(&inp[..], &__ret[..], !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_292] = { let __args: [G; IN_292] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__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];
@@ -27990,8 +28178,8 @@ fn aiur_fn_292(
             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_292] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95];
-            record.function_queries[292].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_297] = [__v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95];
+            record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -28003,15 +28191,15 @@ fn aiur_fn_292(
   })
 }
 
-const INPUT_SIZE_293: usize = 1;
-const IN_293: usize = 1;
-const OUT_293: usize = 8;
-fn aiur_fn_293(
-  inp: [G; IN_293],
+const INPUT_SIZE_298: usize = 1;
+const IN_298: usize = 1;
+const OUT_298: usize = 8;
+fn aiur_fn_298(
+  inp: [G; IN_298],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_293], ExecError> {
+) -> Result<[G; OUT_298], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __gb: [u8; 8] = __v_0.as_canonical_u64().to_le_bytes();
@@ -28032,26 +28220,26 @@ fn aiur_fn_293(
     if (__v_9 != __v_0) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection index bytes do not recompose to the index".to_string()) });
     }
-    let __ret: [G; OUT_293] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
-    record.function_queries[293].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_298] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8];
+    record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_294: usize = 3;
-const IN_294: usize = 3;
-const OUT_294: usize = 1;
-fn aiur_fn_294(
-  inp: [G; IN_294],
+const INPUT_SIZE_299: usize = 3;
+const IN_299: usize = 3;
+const OUT_299: usize = 1;
+fn aiur_fn_299(
+  inp: [G; IN_299],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_294], ExecError> {
+) -> Result<[G; OUT_299], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__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];
@@ -28097,7 +28285,7 @@ fn aiur_fn_294(
     let __v_45: G = __r_arr[42];
     let __v_46: G = __r_arr[43];
     let __v_47: G = __r_arr[44];
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__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];
@@ -28184,46 +28372,46 @@ fn aiur_fn_294(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__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; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_113: G = __r_arr[0];
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_113]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_114: G = __r_arr[0];
-    let __ret: [G; OUT_294] = [__v_114];
-    record.function_queries[294].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_299] = [__v_114];
+    record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_295: usize = 2;
-const IN_295: usize = 2;
-const OUT_295: usize = 1;
-fn aiur_fn_295(
-  inp: [G; IN_295],
+const INPUT_SIZE_300: usize = 2;
+const IN_300: usize = 2;
+const OUT_300: usize = 1;
+fn aiur_fn_300(
+  inp: [G; IN_300],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_295], ExecError> {
+) -> Result<[G; OUT_300], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_295] = [__v_3];
-    record.function_queries[295].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_300] = [__v_3];
+    record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_296: usize = 4;
-const IN_296: usize = 4;
-const OUT_296: usize = 1;
-fn aiur_fn_296(
-  inp: [G; IN_296],
+const INPUT_SIZE_301: usize = 4;
+const IN_301: usize = 4;
+const OUT_301: usize = 1;
+fn aiur_fn_301(
+  inp: [G; IN_301],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_296], ExecError> {
+) -> Result<[G; OUT_301], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28282,21 +28470,21 @@ fn aiur_fn_296(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_296] = [__v_53];
-        record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_301] = [__v_53];
+        record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__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_296] = { let __args: [G; IN_296] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[296].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[296].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[296].bump_multiplicity(__i); } let __ret: [G; OUT_296] = unsafe { *(record.function_queries[296].output_at(__i).as_ptr() as *const [G; OUT_296]) }; __ret }, _ => aiur_fn_296(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_0, __v_1, __v_50, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_296] = [__v_56];
-        record.function_queries[296].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_301] = [__v_56];
+        record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -28306,15 +28494,15 @@ fn aiur_fn_296(
   })
 }
 
-const INPUT_SIZE_297: usize = 1;
-const IN_297: usize = 1;
-const OUT_297: usize = 1;
-fn aiur_fn_297(
-  inp: [G; IN_297],
+const INPUT_SIZE_302: usize = 1;
+const IN_302: usize = 1;
+const OUT_302: usize = 1;
+fn aiur_fn_302(
+  inp: [G; IN_302],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_297], ExecError> {
+) -> Result<[G; OUT_302], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -28324,57 +28512,57 @@ fn aiur_fn_297(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_297] = [__v_4];
-        record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_302] = [__v_4];
+        record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_297] = [__v_4];
-        record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_302] = [__v_4];
+        record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_297] = [__v_4];
-        record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_302] = [__v_4];
+        record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
             match __v_5.as_canonical_u64() {
               0u64 => {
                 let __v_6: G = G::from_u64(0);
-                let __ret: [G; OUT_297] = [__v_6];
-                record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_302] = [__v_6];
+                record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_6: G = G::from_u64(1);
-                let __ret: [G; OUT_297] = [__v_6];
-                record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_302] = [__v_6];
+                record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_297] = [__v_6];
-            record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_302] = [__v_6];
+            record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_297] = [__v_4];
-        record.function_queries[297].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_302] = [__v_4];
+        record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -28384,15 +28572,15 @@ fn aiur_fn_297(
   })
 }
 
-const INPUT_SIZE_298: usize = 2;
-const IN_298: usize = 2;
-const OUT_298: usize = 1;
-fn aiur_fn_298(
-  inp: [G; IN_298],
+const INPUT_SIZE_303: usize = 2;
+const IN_303: usize = 2;
+const OUT_303: usize = 1;
+fn aiur_fn_303(
+  inp: [G; IN_303],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_298], ExecError> {
+) -> Result<[G; OUT_303], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28409,14 +28597,14 @@ fn aiur_fn_298(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -28428,16 +28616,16 @@ fn aiur_fn_298(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -28449,19 +28637,19 @@ fn aiur_fn_298(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_298] = [__v_10];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_10];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -28473,19 +28661,19 @@ fn aiur_fn_298(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = (__v_8 * __v_9);
-            let __ret: [G; OUT_298] = [__v_10];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_10];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -28499,14 +28687,14 @@ fn aiur_fn_298(
           4u64 => {
             let __v_8: G = (__v_3 - __v_6);
             let __v_9: G = G::from_bool((__v_8 == G::ZERO));
-            let __ret: [G; OUT_298] = [__v_9];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_9];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_298] = [__v_8];
-            record.function_queries[298].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_303] = [__v_8];
+            record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -28518,15 +28706,15 @@ fn aiur_fn_298(
   })
 }
 
-const INPUT_SIZE_299: usize = 2;
-const IN_299: usize = 2;
-const OUT_299: usize = 1;
-fn aiur_fn_299(
-  inp: [G; IN_299],
+const INPUT_SIZE_304: usize = 2;
+const IN_304: usize = 2;
+const OUT_304: usize = 1;
+fn aiur_fn_304(
+  inp: [G; IN_304],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_299], ExecError> {
+) -> Result<[G; OUT_304], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28543,14 +28731,14 @@ fn aiur_fn_299(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_299] = [__v_8];
-            record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_304] = [__v_8];
+            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_299] = [__v_8];
-            record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_304] = [__v_8];
+            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -28566,8 +28754,8 @@ fn aiur_fn_299(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_299] = [__v_8];
-            record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_304] = [__v_8];
+            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -28575,8 +28763,8 @@ fn aiur_fn_299(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_299] = [__v_9];
-                record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_304] = [__v_9];
+                record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
@@ -28584,15 +28772,15 @@ fn aiur_fn_299(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(2);
-                    let __ret: [G; OUT_299] = [__v_10];
-                    record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_304] = [__v_10];
+                    record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_299] = [__v_10];
-                    record.function_queries[299].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_304] = [__v_10];
+                    record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -28617,15 +28805,15 @@ fn aiur_fn_299(
   })
 }
 
-const INPUT_SIZE_300: usize = 2;
-const IN_300: usize = 2;
-const OUT_300: usize = 1;
-fn aiur_fn_300(
-  inp: [G; IN_300],
+const INPUT_SIZE_305: usize = 2;
+const IN_305: usize = 2;
+const OUT_305: usize = 1;
+fn aiur_fn_305(
+  inp: [G; IN_305],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_300], ExecError> {
+) -> Result<[G; OUT_305], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28636,8 +28824,8 @@ fn aiur_fn_300(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_300] = [__v_5];
-        record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_305] = [__v_5];
+        record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -28648,8 +28836,8 @@ fn aiur_fn_300(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_300] = [__v_8];
-            record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_305] = [__v_8];
+            record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -28657,25 +28845,25 @@ fn aiur_fn_300(
             match __v_8.as_canonical_u64() {
               1u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_300] = [__v_9];
-                record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_305] = [__v_9];
+                record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_9: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_300] = [__v_10];
-                    record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_305] = [__v_10];
+                    record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_300] = [__v_10];
-                    record.function_queries[300].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_305] = [__v_10];
+                    record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -28700,15 +28888,15 @@ fn aiur_fn_300(
   })
 }
 
-const INPUT_SIZE_301: usize = 2;
-const IN_301: usize = 2;
-const OUT_301: usize = 1;
-fn aiur_fn_301(
-  inp: [G; IN_301],
+const INPUT_SIZE_306: usize = 2;
+const IN_306: usize = 2;
+const OUT_306: usize = 1;
+fn aiur_fn_306(
+  inp: [G; IN_306],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_301], ExecError> {
+) -> Result<[G; OUT_306], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28725,14 +28913,14 @@ fn aiur_fn_301(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_301] = [__v_8];
-            record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_306] = [__v_8];
+            record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_301] = [__v_8];
-            record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_306] = [__v_8];
+            record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -28748,15 +28936,15 @@ fn aiur_fn_301(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_301] = [__v_8];
-            record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_306] = [__v_8];
+            record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_301] = [__v_8];
-            record.function_queries[301].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_306] = [__v_8];
+            record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -28771,15 +28959,15 @@ fn aiur_fn_301(
   })
 }
 
-const INPUT_SIZE_302: usize = 2;
-const IN_302: usize = 2;
-const OUT_302: usize = 2;
-fn aiur_fn_302(
-  inp: [G; IN_302],
+const INPUT_SIZE_307: usize = 2;
+const IN_307: usize = 2;
+const OUT_307: usize = 2;
+fn aiur_fn_307(
+  inp: [G; IN_307],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_302], ExecError> {
+) -> Result<[G; OUT_307], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28795,8 +28983,8 @@ fn aiur_fn_302(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_302] = [__v_5, __v_10];
-        record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_307] = [__v_5, __v_10];
+        record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -28806,8 +28994,8 @@ fn aiur_fn_302(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_302] = [__v_6, __v_8];
-            record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_307] = [__v_6, __v_8];
+            record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -28815,18 +29003,18 @@ fn aiur_fn_302(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_302] = [__v_7, __v_1];
-                record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_307] = [__v_7, __v_1];
+                record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_302] = [__v_7, __v_10];
-                record.function_queries[302].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_307] = [__v_7, __v_10];
+                record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -28846,15 +29034,15 @@ fn aiur_fn_302(
   })
 }
 
-const INPUT_SIZE_303: usize = 3;
-const IN_303: usize = 3;
-const OUT_303: usize = 1;
-fn aiur_fn_303(
-  inp: [G; IN_303],
+const INPUT_SIZE_308: usize = 3;
+const IN_308: usize = 3;
+const OUT_308: usize = 1;
+fn aiur_fn_308(
+  inp: [G; IN_308],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_303], ExecError> {
+) -> Result<[G; OUT_308], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28871,8 +29059,8 @@ fn aiur_fn_303(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_303] = [__v_11];
-        record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_308] = [__v_11];
+        record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -28887,8 +29075,8 @@ fn aiur_fn_303(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_303] = [__v_11];
-                record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_308] = [__v_11];
+                record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
@@ -28896,11 +29084,11 @@ fn aiur_fn_303(
                 match __v_9.as_canonical_u64() {
                   1u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_303] = [__v_12];
-                    record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_308] = [__v_12];
+                    record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
@@ -28910,13 +29098,13 @@ fn aiur_fn_303(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_303] = [__v_13];
-                        record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_308] = [__v_13];
+                        record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __ret: [G; OUT_303] = [__v_0];
-                        record.function_queries[303].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_308] = [__v_0];
+                        record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -28943,15 +29131,15 @@ fn aiur_fn_303(
   })
 }
 
-const INPUT_SIZE_304: usize = 2;
-const IN_304: usize = 2;
-const OUT_304: usize = 1;
-fn aiur_fn_304(
-  inp: [G; IN_304],
+const INPUT_SIZE_309: usize = 2;
+const IN_309: usize = 2;
+const OUT_309: usize = 1;
+fn aiur_fn_309(
+  inp: [G; IN_309],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_304], ExecError> {
+) -> Result<[G; OUT_309], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -28968,14 +29156,14 @@ fn aiur_fn_304(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_304] = [__v_8];
-            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_309] = [__v_8];
+            record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_304] = [__v_8];
-            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_309] = [__v_8];
+            record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -28991,8 +29179,8 @@ fn aiur_fn_304(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_304] = [__v_8];
-            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_309] = [__v_8];
+            record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -29012,24 +29200,24 @@ fn aiur_fn_304(
                         let __v_13: G = (__v_9 - __v_11);
                         match __v_13.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_304] = [__v_14];
-                            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_309] = [__v_14];
+                            record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_14: G = G::from_u64(0);
-                            let __ret: [G; OUT_304] = [__v_14];
-                            record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_309] = [__v_14];
+                            record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_304] = [__v_13];
-                        record.function_queries[304].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_309] = [__v_13];
+                        record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -29050,15 +29238,15 @@ fn aiur_fn_304(
   })
 }
 
-const INPUT_SIZE_305: usize = 1;
-const IN_305: usize = 1;
-const OUT_305: usize = 1;
-fn aiur_fn_305(
-  inp: [G; IN_305],
+const INPUT_SIZE_310: usize = 1;
+const IN_310: usize = 1;
+const OUT_310: usize = 1;
+fn aiur_fn_310(
+  inp: [G; IN_310],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_305], ExecError> {
+) -> Result<[G; OUT_310], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -29068,8 +29256,8 @@ fn aiur_fn_305(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_305] = [__v_4];
-        record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_310] = [__v_4];
+        record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -29078,18 +29266,18 @@ fn aiur_fn_305(
         let __v_5: G = __loaded[1];
         match __v_4.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = { let __a_val = __v_6.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_305] = [__v_5];
-                record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_310] = [__v_5];
+                record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_305] = [__v_6];
-                record.function_queries[305].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_310] = [__v_6];
+                record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -29106,15 +29294,15 @@ fn aiur_fn_305(
   })
 }
 
-const INPUT_SIZE_306: usize = 2;
-const IN_306: usize = 2;
-const OUT_306: usize = 1;
-fn aiur_fn_306(
-  inp: [G; IN_306],
+const INPUT_SIZE_311: usize = 2;
+const IN_311: usize = 2;
+const OUT_311: usize = 1;
+fn aiur_fn_311(
+  inp: [G; IN_311],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_306], ExecError> {
+) -> Result<[G; OUT_311], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29124,8 +29312,8 @@ fn aiur_fn_306(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_306] = [__v_0];
-        record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_311] = [__v_0];
+        record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -29135,8 +29323,8 @@ fn aiur_fn_306(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_306] = [__v_0];
-            record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_311] = [__v_0];
+            record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -29154,21 +29342,21 @@ fn aiur_fn_306(
                     match __v_12.as_canonical_u64() {
                       1u64 => {
                         let __v_13: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_306] = [__v_15];
-                        record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_311] = [__v_15];
+                        record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       0u64 => {
                         let __v_13: G = { let __a_val = __v_10.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                         match __v_13.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
                             let __v_14: G = __r_arr[0];
-                            let __ret: [G; OUT_306] = [__v_14];
-                            record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_311] = [__v_14];
+                            record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           0u64 => {
@@ -29176,18 +29364,18 @@ fn aiur_fn_306(
                             match __v_14.as_canonical_u64() {
                               1u64 => {
                                 let __v_15: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_306] = [__v_17];
-                                record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_311] = [__v_17];
+                                record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               0u64 => {
-                                let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
                                 let __v_15: G = __r_arr[0];
-                                let __ret: [G; OUT_306] = [__v_15];
-                                record.function_queries[306].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_311] = [__v_15];
+                                record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -29221,23 +29409,23 @@ fn aiur_fn_306(
   })
 }
 
-const INPUT_SIZE_307: usize = 3;
-const IN_307: usize = 3;
-const OUT_307: usize = 1;
-fn aiur_fn_307(
-  inp: [G; IN_307],
+const INPUT_SIZE_312: usize = 3;
+const IN_312: usize = 3;
+const OUT_312: usize = 1;
+fn aiur_fn_312(
+  inp: [G; IN_312],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_307], ExecError> {
+) -> Result<[G; OUT_312], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_307] = [__v_0];
-        record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_312] = [__v_0];
+        record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -29247,15 +29435,15 @@ fn aiur_fn_307(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_307] = [__v_6];
-            record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_312] = [__v_6];
+            record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_307] = [__v_0];
-            record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_312] = [__v_0];
+            record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -29264,25 +29452,25 @@ fn aiur_fn_307(
         }
       },
       _ => {
-        let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_307] = [__v_3];
-        record.function_queries[307].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_312] = [__v_3];
+        record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_308: usize = 3;
-const IN_308: usize = 3;
-const OUT_308: usize = 1;
-fn aiur_fn_308(
-  inp: [G; IN_308],
+const INPUT_SIZE_313: usize = 3;
+const IN_313: usize = 3;
+const OUT_313: usize = 1;
+fn aiur_fn_313(
+  inp: [G; IN_313],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_308], ExecError> {
+) -> Result<[G; OUT_313], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29302,8 +29490,8 @@ fn aiur_fn_308(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_308] = [__v_14];
-        record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_313] = [__v_14];
+        record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -29313,7 +29501,7 @@ fn aiur_fn_308(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
@@ -29323,13 +29511,13 @@ fn aiur_fn_308(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_308] = [__v_13];
-                    record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_313] = [__v_13];
+                    record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_308] = [__v_0];
-                    record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_313] = [__v_0];
+                    record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -29344,17 +29532,17 @@ fn aiur_fn_308(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_308] = [__v_15];
-                record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_313] = [__v_15];
+                record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_308] = [__v_12];
-                record.function_queries[308].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_313] = [__v_12];
+                record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -29368,15 +29556,15 @@ fn aiur_fn_308(
   })
 }
 
-const INPUT_SIZE_309: usize = 4;
-const IN_309: usize = 4;
-const OUT_309: usize = 1;
-fn aiur_fn_309(
-  inp: [G; IN_309],
+const INPUT_SIZE_314: usize = 4;
+const IN_314: usize = 4;
+const OUT_314: usize = 1;
+fn aiur_fn_314(
+  inp: [G; IN_314],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_309], ExecError> {
+) -> Result<[G; OUT_314], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29401,8 +29589,8 @@ fn aiur_fn_309(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_309] = [__v_19];
-        record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_314] = [__v_19];
+        record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -29412,17 +29600,17 @@ fn aiur_fn_309(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[308].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[308].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[308].bump_multiplicity(__i); } let __ret: [G; OUT_308] = unsafe { *(record.function_queries[308].output_at(__i).as_ptr() as *const [G; OUT_308]) }; __ret }, _ => aiur_fn_308(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_309] = [__v_14];
-                record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_314] = [__v_14];
+                record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
@@ -29436,17 +29624,17 @@ fn aiur_fn_309(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_309] = [__v_20];
-                record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_314] = [__v_20];
+                record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_309] = [__v_13];
-                record.function_queries[309].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_314] = [__v_13];
+                record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -29460,15 +29648,15 @@ fn aiur_fn_309(
   })
 }
 
-const INPUT_SIZE_310: usize = 4;
-const IN_310: usize = 4;
-const OUT_310: usize = 1;
-fn aiur_fn_310(
-  inp: [G; IN_310],
+const INPUT_SIZE_315: usize = 4;
+const IN_315: usize = 4;
+const OUT_315: usize = 1;
+fn aiur_fn_315(
+  inp: [G; IN_315],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_310], ExecError> {
+) -> Result<[G; OUT_315], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29480,63 +29668,63 @@ fn aiur_fn_310(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_7];
-        record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_315] = [__v_7];
+        record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_9];
-        record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_315] = [__v_9];
+        record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_1, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_8];
-        record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_315] = [__v_8];
+        record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_310] = [__v_7];
-        record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_315] = [__v_7];
+        record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9, __v_8, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_310] = [__v_10];
-            record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_315] = [__v_10];
+            record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             match __v_2.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_310] = [__v_3];
-                record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_315] = [__v_3];
+                record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3, __v_1, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_310] = [__v_9];
-                record.function_queries[310].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_315] = [__v_9];
+                record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -29553,15 +29741,15 @@ fn aiur_fn_310(
   })
 }
 
-const INPUT_SIZE_311: usize = 5;
-const IN_311: usize = 5;
-const OUT_311: usize = 1;
-fn aiur_fn_311(
-  inp: [G; IN_311],
+const INPUT_SIZE_316: usize = 5;
+const IN_316: usize = 5;
+const OUT_316: usize = 1;
+fn aiur_fn_316(
+  inp: [G; IN_316],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_311], ExecError> {
+) -> Result<[G; OUT_316], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29574,55 +29762,55 @@ fn aiur_fn_311(
     let __v_7: G = __loaded[2];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_311] = [__v_8];
-        record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_316] = [__v_8];
+        record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_3 + __v_8);
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_2, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_311] = [__v_11];
-        record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_316] = [__v_11];
+        record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_6, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_311] = [__v_9];
-        record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_316] = [__v_9];
+        record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_0, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7, __v_2, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_311] = [__v_9];
-        record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_316] = [__v_9];
+        record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[307].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[307].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[307].bump_multiplicity(__i); } let __ret: [G; OUT_307] = unsafe { *(record.function_queries[307].output_at(__i).as_ptr() as *const [G; OUT_307]) }; __ret }, _ => aiur_fn_307(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_10, __v_9, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_9, __v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_311] = [__v_12];
-            record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_316] = [__v_12];
+            record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -29631,17 +29819,17 @@ fn aiur_fn_311(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_4, __v_2, __v_6, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     break '__mc_0 [__v_10];
   },
 }
  };
             let __v_10: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_311] = [__v_11];
-            record.function_queries[311].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_316] = [__v_11];
+            record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -29656,15 +29844,15 @@ fn aiur_fn_311(
   })
 }
 
-const INPUT_SIZE_312: usize = 2;
-const IN_312: usize = 2;
-const OUT_312: usize = 1;
-fn aiur_fn_312(
-  inp: [G; IN_312],
+const INPUT_SIZE_317: usize = 2;
+const IN_317: usize = 2;
+const OUT_317: usize = 1;
+fn aiur_fn_317(
+  inp: [G; IN_317],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_312], ExecError> {
+) -> Result<[G; OUT_317], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29674,19 +29862,19 @@ fn aiur_fn_312(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_312] = [__v_0];
-        record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_317] = [__v_0];
+        record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_312] = [__v_8];
-        record.function_queries[312].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_317] = [__v_8];
+        record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -29696,15 +29884,15 @@ fn aiur_fn_312(
   })
 }
 
-const INPUT_SIZE_313: usize = 2;
-const IN_313: usize = 2;
-const OUT_313: usize = 1;
-fn aiur_fn_313(
-  inp: [G; IN_313],
+const INPUT_SIZE_318: usize = 2;
+const IN_318: usize = 2;
+const OUT_318: usize = 1;
+fn aiur_fn_318(
+  inp: [G; IN_318],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_313], ExecError> {
+) -> Result<[G; OUT_318], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -29714,8 +29902,8 @@ fn aiur_fn_313(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_313] = [__v_0];
-        record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_318] = [__v_0];
+        record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -29731,18 +29919,18 @@ fn aiur_fn_313(
             let __v_10: G = __loaded[2];
             match __v_8.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_8, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_8, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_313] = [__v_12];
-                    record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_318] = [__v_12];
+                    record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[301].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[301].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[301].bump_multiplicity(__i); } let __ret: [G; OUT_301] = unsafe { *(record.function_queries[301].output_at(__i).as_ptr() as *const [G; OUT_301]) }; __ret }, _ => aiur_fn_301(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() {
   0u64 => {
@@ -29775,7 +29963,7 @@ fn aiur_fn_313(
     break '__mc_2 [__v_17];
   },
   0u64 => {
-    let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__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);
@@ -29816,7 +30004,7 @@ fn aiur_fn_313(
         break '__mc_3 [__v_7];
       },
       0u64 => {
-        let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[306].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[306].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[306].bump_multiplicity(__i); } let __ret: [G; OUT_306] = unsafe { *(record.function_queries[306].output_at(__i).as_ptr() as *const [G; OUT_306]) }; __ret }, _ => aiur_fn_306(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[311].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[311].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[311].bump_multiplicity(__i); } let __ret: [G; OUT_311] = unsafe { *(record.function_queries[311].output_at(__i).as_ptr() as *const [G; OUT_311]) }; __ret }, _ => aiur_fn_311(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
         break '__mc_3 [__v_17];
       },
@@ -29832,10 +30020,10 @@ fn aiur_fn_313(
  };
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[313].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[313].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[313].bump_multiplicity(__i); } let __ret: [G; OUT_313] = unsafe { *(record.function_queries[313].output_at(__i).as_ptr() as *const [G; OUT_313]) }; __ret }, _ => aiur_fn_313(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
-                    let __ret: [G; OUT_313] = [__v_16];
-                    record.function_queries[313].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_318] = [__v_16];
+                    record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -29851,15 +30039,15 @@ fn aiur_fn_313(
   })
 }
 
-const INPUT_SIZE_314: usize = 1;
-const IN_314: usize = 1;
-const OUT_314: usize = 1;
-fn aiur_fn_314(
-  inp: [G; IN_314],
+const INPUT_SIZE_319: usize = 1;
+const IN_319: usize = 1;
+const OUT_319: usize = 1;
+fn aiur_fn_319(
+  inp: [G; IN_319],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_314], ExecError> {
+) -> Result<[G; OUT_319], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -29868,8 +30056,8 @@ fn aiur_fn_314(
     let __v_3: G = __loaded[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_314] = [__v_0];
-        record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_319] = [__v_0];
+        record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -29887,15 +30075,15 @@ fn aiur_fn_314(
                 let __v_9: G = __loaded[2];
                 match __v_7.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_314] = [__v_10];
-                    record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_319] = [__v_10];
+                    record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __ret: [G; OUT_314] = [__v_0];
-                    record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_319] = [__v_0];
+                    record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -29904,8 +30092,8 @@ fn aiur_fn_314(
                 }
               },
               _ => {
-                let __ret: [G; OUT_314] = [__v_0];
-                record.function_queries[314].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_319] = [__v_0];
+                record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -29919,21 +30107,21 @@ fn aiur_fn_314(
   })
 }
 
-const INPUT_SIZE_315: usize = 2;
-const IN_315: usize = 2;
-const OUT_315: usize = 1;
-fn aiur_fn_315(
-  inp: [G; IN_315],
+const INPUT_SIZE_320: usize = 2;
+const IN_320: usize = 2;
+const OUT_320: usize = 1;
+fn aiur_fn_320(
+  inp: [G; IN_320],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_315], ExecError> {
+) -> Result<[G; OUT_320], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[314].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[314].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[314].bump_multiplicity(__i); } let __ret: [G; OUT_314] = unsafe { *(record.function_queries[314].output_at(__i).as_ptr() as *const [G; OUT_314]) }; __ret }, _ => aiur_fn_314(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -29948,14 +30136,14 @@ fn aiur_fn_315(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_315] = [__v_10];
-            record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_320] = [__v_10];
+            record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_315] = [__v_10];
-            record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_320] = [__v_10];
+            record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -29971,8 +30159,8 @@ fn aiur_fn_315(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_315] = [__v_10];
-            record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_320] = [__v_10];
+            record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -29988,27 +30176,27 @@ fn aiur_fn_315(
                 let __v_15: G = __loaded[2];
                 match __v_13.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } };
                     let __v_16: G = __r_arr[0];
                     match __v_16.as_canonical_u64() {
                       0u64 => {
                         let __v_17: G = (__v_11 - __v_14);
                         match __v_17.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[304].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[304].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[304].bump_multiplicity(__i); } let __ret: [G; OUT_304] = unsafe { *(record.function_queries[304].output_at(__i).as_ptr() as *const [G; OUT_304]) }; __ret }, _ => aiur_fn_304(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[309].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[309].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[309].bump_multiplicity(__i); } let __ret: [G; OUT_309] = unsafe { *(record.function_queries[309].output_at(__i).as_ptr() as *const [G; OUT_309]) }; __ret }, _ => aiur_fn_309(__args, record, io_buffer, __cu)? } };
                             let __v_18: G = __r_arr[0];
                             match __v_18.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } };
                                 let __v_19: G = __r_arr[0];
-                                let __ret: [G; OUT_315] = [__v_19];
-                                record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_320] = [__v_19];
+                                record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               0u64 => {
                                 let __v_19: G = G::from_u64(0);
-                                let __ret: [G; OUT_315] = [__v_19];
-                                record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_320] = [__v_19];
+                                record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -30018,16 +30206,16 @@ fn aiur_fn_315(
                           },
                           _ => {
                             let __v_18: G = G::from_u64(0);
-                            let __ret: [G; OUT_315] = [__v_18];
-                            record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_320] = [__v_18];
+                            record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_17: G = G::from_u64(0);
-                        let __ret: [G; OUT_315] = [__v_17];
-                        record.function_queries[315].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_320] = [__v_17];
+                        record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -30048,15 +30236,15 @@ fn aiur_fn_315(
   })
 }
 
-const INPUT_SIZE_316: usize = 3;
-const IN_316: usize = 3;
-const OUT_316: usize = 1;
-fn aiur_fn_316(
-  inp: [G; IN_316],
+const INPUT_SIZE_321: usize = 3;
+const IN_321: usize = 3;
+const OUT_321: usize = 1;
+fn aiur_fn_321(
+  inp: [G; IN_321],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_316], ExecError> {
+) -> Result<[G; OUT_321], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30068,8 +30256,8 @@ fn aiur_fn_316(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_316] = [__v_6];
-        record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_321] = [__v_6];
+        record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30079,14 +30267,14 @@ fn aiur_fn_316(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_316] = [__v_10];
-                record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_321] = [__v_10];
+                record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -30097,7 +30285,7 @@ fn aiur_fn_316(
     break '__mc_0 [__v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     break '__mc_0 [__v_11];
   },
@@ -30110,15 +30298,15 @@ fn aiur_fn_316(
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_316] = [__v_12];
-                    record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_321] = [__v_12];
+                    record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_316] = [__v_12];
-                    record.function_queries[316].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_321] = [__v_12];
+                    record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30137,15 +30325,15 @@ fn aiur_fn_316(
   })
 }
 
-const INPUT_SIZE_317: usize = 2;
-const IN_317: usize = 2;
-const OUT_317: usize = 1;
-fn aiur_fn_317(
-  inp: [G; IN_317],
+const INPUT_SIZE_322: usize = 2;
+const IN_322: usize = 2;
+const OUT_322: usize = 1;
+fn aiur_fn_322(
+  inp: [G; IN_322],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_317], ExecError> {
+) -> Result<[G; OUT_322], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30156,8 +30344,8 @@ fn aiur_fn_317(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_317] = [__v_5];
-        record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_322] = [__v_5];
+        record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30172,15 +30360,15 @@ fn aiur_fn_317(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_317] = [__v_10];
-                record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_322] = [__v_10];
+                record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_317] = [__v_10];
-                record.function_queries[317].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_322] = [__v_10];
+                record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -30197,15 +30385,15 @@ fn aiur_fn_317(
   })
 }
 
-const INPUT_SIZE_318: usize = 4;
-const IN_318: usize = 4;
-const OUT_318: usize = 1;
-fn aiur_fn_318(
-  inp: [G; IN_318],
+const INPUT_SIZE_323: usize = 4;
+const IN_323: usize = 4;
+const OUT_323: usize = 1;
+fn aiur_fn_323(
+  inp: [G; IN_323],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_318], ExecError> {
+) -> Result<[G; OUT_323], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30218,8 +30406,8 @@ fn aiur_fn_318(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_318] = [__v_7];
-        record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_323] = [__v_7];
+        record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30229,31 +30417,31 @@ fn aiur_fn_318(
         let __v_9: G = __loaded[2];
         match __v_7.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[305].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[305].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[305].bump_multiplicity(__i); } let __ret: [G; OUT_305] = unsafe { *(record.function_queries[305].output_at(__i).as_ptr() as *const [G; OUT_305]) }; __ret }, _ => aiur_fn_305(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_318] = [__v_11];
-                record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_323] = [__v_11];
+                record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_318] = [__v_12];
-                    record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_323] = [__v_12];
+                    record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_318] = [__v_12];
-                    record.function_queries[318].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_323] = [__v_12];
+                    record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30272,15 +30460,15 @@ fn aiur_fn_318(
   })
 }
 
-const INPUT_SIZE_319: usize = 3;
-const IN_319: usize = 3;
-const OUT_319: usize = 1;
-fn aiur_fn_319(
-  inp: [G; IN_319],
+const INPUT_SIZE_324: usize = 3;
+const IN_324: usize = 3;
+const OUT_324: usize = 1;
+fn aiur_fn_324(
+  inp: [G; IN_324],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_319], ExecError> {
+) -> Result<[G; OUT_324], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30292,8 +30480,8 @@ fn aiur_fn_319(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_319] = [__v_6];
-        record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_324] = [__v_6];
+        record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30309,15 +30497,15 @@ fn aiur_fn_319(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_319] = [__v_10];
-                    record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_324] = [__v_10];
+                    record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_319] = [__v_10];
-                    record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_324] = [__v_10];
+                    record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30326,10 +30514,10 @@ fn aiur_fn_319(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[319].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[319].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[319].bump_multiplicity(__i); } let __ret: [G; OUT_319] = unsafe { *(record.function_queries[319].output_at(__i).as_ptr() as *const [G; OUT_319]) }; __ret }, _ => aiur_fn_319(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_319] = [__v_9];
-                record.function_queries[319].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_324] = [__v_9];
+                record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -30343,15 +30531,15 @@ fn aiur_fn_319(
   })
 }
 
-const INPUT_SIZE_320: usize = 2;
-const IN_320: usize = 2;
-const OUT_320: usize = 1;
-fn aiur_fn_320(
-  inp: [G; IN_320],
+const INPUT_SIZE_325: usize = 2;
+const IN_325: usize = 2;
+const OUT_325: usize = 1;
+fn aiur_fn_325(
+  inp: [G; IN_325],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_320], ExecError> {
+) -> Result<[G; OUT_325], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30362,8 +30550,8 @@ fn aiur_fn_320(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_320] = [__v_5];
-        record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_325] = [__v_5];
+        record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30379,7 +30567,7 @@ fn aiur_fn_320(
     break '__mc_0 [__v_8];
   },
   _ => {
-    let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[316].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[316].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[316].bump_multiplicity(__i); } let __ret: [G; OUT_316] = unsafe { *(record.function_queries[316].output_at(__i).as_ptr() as *const [G; OUT_316]) }; __ret }, _ => aiur_fn_316(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     break '__mc_0 [__v_8];
   },
@@ -30389,25 +30577,25 @@ fn aiur_fn_320(
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_320] = [__v_9];
-                record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_325] = [__v_9];
+                record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_320] = [__v_10];
-                    record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_325] = [__v_10];
+                    record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
-                    let __ret: [G; OUT_320] = [__v_10];
-                    record.function_queries[320].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_325] = [__v_10];
+                    record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -30429,15 +30617,15 @@ fn aiur_fn_320(
   })
 }
 
-const INPUT_SIZE_321: usize = 3;
-const IN_321: usize = 3;
-const OUT_321: usize = 1;
-fn aiur_fn_321(
-  inp: [G; IN_321],
+const INPUT_SIZE_326: usize = 3;
+const IN_326: usize = 3;
+const OUT_326: usize = 1;
+fn aiur_fn_326(
+  inp: [G; IN_326],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_321], ExecError> {
+) -> Result<[G; OUT_326], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30449,8 +30637,8 @@ fn aiur_fn_321(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_321] = [__v_6];
-        record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_326] = [__v_6];
+        record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30459,20 +30647,20 @@ fn aiur_fn_321(
         let __v_7: G = __loaded[1];
         match __v_6.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[318].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[318].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[318].bump_multiplicity(__i); } let __ret: [G; OUT_318] = unsafe { *(record.function_queries[318].output_at(__i).as_ptr() as *const [G; OUT_318]) }; __ret }, _ => aiur_fn_318(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_321] = [__v_9];
-                record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_326] = [__v_9];
+                record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
-                let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[321].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[321].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[321].bump_multiplicity(__i); } let __ret: [G; OUT_321] = unsafe { *(record.function_queries[321].output_at(__i).as_ptr() as *const [G; OUT_321]) }; __ret }, _ => aiur_fn_321(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_321] = [__v_9];
-                record.function_queries[321].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_326] = [__v_9];
+                record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -30489,15 +30677,15 @@ fn aiur_fn_321(
   })
 }
 
-const INPUT_SIZE_322: usize = 1;
-const IN_322: usize = 1;
-const OUT_322: usize = 1;
-fn aiur_fn_322(
-  inp: [G; IN_322],
+const INPUT_SIZE_327: usize = 1;
+const IN_327: usize = 1;
+const OUT_327: usize = 1;
+fn aiur_fn_327(
+  inp: [G; IN_327],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_322], ExecError> {
+) -> Result<[G; OUT_327], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(0);
@@ -30517,35 +30705,35 @@ fn aiur_fn_322(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_310] = { let __args: [G; IN_310] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[310].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[310].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[310].bump_multiplicity(__i); } let __ret: [G; OUT_310] = unsafe { *(record.function_queries[310].output_at(__i).as_ptr() as *const [G; OUT_310]) }; __ret }, _ => aiur_fn_310(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0, __v_16, __v_17, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[312].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[312].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[312].bump_multiplicity(__i); } let __ret: [G; OUT_312] = unsafe { *(record.function_queries[312].output_at(__i).as_ptr() as *const [G; OUT_312]) }; __ret }, _ => aiur_fn_312(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_18, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[317].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[317].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[317].bump_multiplicity(__i); } let __ret: [G; OUT_317] = unsafe { *(record.function_queries[317].output_at(__i).as_ptr() as *const [G; OUT_317]) }; __ret }, _ => aiur_fn_317(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __ret: [G; OUT_322] = [__v_19];
-    record.function_queries[322].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_327] = [__v_19];
+    record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_323: usize = 2;
-const IN_323: usize = 2;
-const OUT_323: usize = 1;
-fn aiur_fn_323(
-  inp: [G; IN_323],
+const INPUT_SIZE_328: usize = 2;
+const IN_328: usize = 2;
+const OUT_328: usize = 1;
+fn aiur_fn_328(
+  inp: [G; IN_328],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_323], ExecError> {
+) -> Result<[G; OUT_328], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_323] = [__v_3];
-        record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_328] = [__v_3];
+        record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30556,19 +30744,19 @@ fn aiur_fn_323(
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_323] = [__v_6];
-            record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_328] = [__v_6];
+            record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_323] = [__v_8];
-            record.function_queries[323].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_328] = [__v_8];
+            record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -30580,36 +30768,36 @@ fn aiur_fn_323(
   })
 }
 
-const INPUT_SIZE_324: usize = 2;
-const IN_324: usize = 2;
-const OUT_324: usize = 1;
-fn aiur_fn_324(
-  inp: [G; IN_324],
+const INPUT_SIZE_329: usize = 2;
+const IN_329: usize = 2;
+const OUT_329: usize = 1;
+fn aiur_fn_329(
+  inp: [G; IN_329],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_324], ExecError> {
+) -> Result<[G; OUT_329], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_324] = [__v_3];
-        record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_329] = [__v_3];
+        record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[322].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[322].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[322].bump_multiplicity(__i); } let __ret: [G; OUT_322] = unsafe { *(record.function_queries[322].output_at(__i).as_ptr() as *const [G; OUT_322]) }; __ret }, _ => aiur_fn_322(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[315].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[315].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[315].bump_multiplicity(__i); } let __ret: [G; OUT_315] = unsafe { *(record.function_queries[315].output_at(__i).as_ptr() as *const [G; OUT_315]) }; __ret }, _ => aiur_fn_315(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[320].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[320].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[320].bump_multiplicity(__i); } let __ret: [G; OUT_320] = unsafe { *(record.function_queries[320].output_at(__i).as_ptr() as *const [G; OUT_320]) }; __ret }, _ => aiur_fn_320(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_324] = [__v_5];
-        record.function_queries[324].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_329] = [__v_5];
+        record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -30619,24 +30807,24 @@ fn aiur_fn_324(
   })
 }
 
-const INPUT_SIZE_325: usize = 2;
-const IN_325: usize = 2;
-const OUT_325: usize = 1;
-fn aiur_fn_325(
-  inp: [G; IN_325],
+const INPUT_SIZE_330: usize = 2;
+const IN_330: usize = 2;
+const OUT_330: usize = 1;
+fn aiur_fn_330(
+  inp: [G; IN_330],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_325], ExecError> {
+) -> Result<[G; OUT_330], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         match __v_4.as_canonical_u64() {
@@ -30644,13 +30832,13 @@ fn aiur_fn_325(
             let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_325] = [__v_1];
-                record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_330] = [__v_1];
+                record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
-                let __ret: [G; OUT_325] = [__v_0];
-                record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_330] = [__v_0];
+                record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -30659,43 +30847,43 @@ fn aiur_fn_325(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_325] = [__v_6];
-            record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_330] = [__v_6];
+            record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[326].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[326].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[326].bump_multiplicity(__i); } let __ret: [G; OUT_326] = unsafe { *(record.function_queries[326].output_at(__i).as_ptr() as *const [G; OUT_326]) }; __ret }, _ => aiur_fn_326(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_325] = [__v_4];
-        record.function_queries[325].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_330] = [__v_4];
+        record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_326: usize = 2;
-const IN_326: usize = 2;
-const OUT_326: usize = 1;
-fn aiur_fn_326(
-  inp: [G; IN_326],
+const INPUT_SIZE_331: usize = 2;
+const IN_331: usize = 2;
+const OUT_331: usize = 1;
+fn aiur_fn_331(
+  inp: [G; IN_331],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_326], ExecError> {
+) -> Result<[G; OUT_331], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_326] = [__v_0];
-        record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_331] = [__v_0];
+        record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -30705,8 +30893,8 @@ fn aiur_fn_326(
         let __v_5: G = __loaded[2];
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_326] = [__v_1];
-            record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_331] = [__v_1];
+            record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -30716,33 +30904,33 @@ fn aiur_fn_326(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_326] = [__v_0];
-                record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_331] = [__v_0];
+                record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_326] = [__v_1];
-                    record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_331] = [__v_1];
+                    record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_326] = [__v_0];
-                        record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_331] = [__v_0];
+                        record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       0u64 => {
-                        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
-                        let __ret: [G; OUT_326] = [__v_11];
-                        record.function_queries[326].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_331] = [__v_11];
+                        record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -30766,15 +30954,15 @@ fn aiur_fn_326(
   })
 }
 
-const INPUT_SIZE_327: usize = 2;
-const IN_327: usize = 2;
-const OUT_327: usize = 1;
-fn aiur_fn_327(
-  inp: [G; IN_327],
+const INPUT_SIZE_332: usize = 2;
+const IN_332: usize = 2;
+const OUT_332: usize = 1;
+fn aiur_fn_332(
+  inp: [G; IN_332],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_327], ExecError> {
+) -> Result<[G; OUT_332], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30782,8 +30970,8 @@ fn aiur_fn_327(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_327] = [__v_3];
-        record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_332] = [__v_3];
+        record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -30800,14 +30988,14 @@ fn aiur_fn_327(
             match __v_6.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(1);
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -30819,16 +31007,16 @@ fn aiur_fn_327(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -30840,19 +31028,19 @@ fn aiur_fn_327(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_327] = [__v_11];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_11];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -30864,19 +31052,19 @@ fn aiur_fn_327(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __v_11: G = (__v_9 * __v_10);
-                let __ret: [G; OUT_327] = [__v_11];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_11];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -30892,22 +31080,22 @@ fn aiur_fn_327(
                 match __v_9.as_canonical_u64() {
                   0u64 => {
                     let __v_10: G = G::from_u64(1);
-                    let __ret: [G; OUT_327] = [__v_10];
-                    record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_332] = [__v_10];
+                    record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_10: G = G::from_u64(0);
-                    let __ret: [G; OUT_327] = [__v_10];
-                    record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_332] = [__v_10];
+                    record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_327] = [__v_9];
-                record.function_queries[327].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_332] = [__v_9];
+                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -30921,15 +31109,15 @@ fn aiur_fn_327(
   })
 }
 
-const INPUT_SIZE_328: usize = 2;
-const IN_328: usize = 2;
-const OUT_328: usize = 1;
-fn aiur_fn_328(
-  inp: [G; IN_328],
+const INPUT_SIZE_333: usize = 2;
+const IN_333: usize = 2;
+const OUT_333: usize = 1;
+fn aiur_fn_333(
+  inp: [G; IN_333],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_328], ExecError> {
+) -> Result<[G; OUT_333], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -30939,20 +31127,20 @@ fn aiur_fn_328(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_328] = [__v_6];
-            record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_333] = [__v_6];
+            record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_328] = [__v_6];
-            record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_333] = [__v_6];
+            record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -30962,48 +31150,48 @@ fn aiur_fn_328(
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_328] = [__v_5];
-        record.function_queries[328].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_333] = [__v_5];
+        record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_329: usize = 2;
-const IN_329: usize = 2;
-const OUT_329: usize = 1;
-fn aiur_fn_329(
-  inp: [G; IN_329],
+const INPUT_SIZE_334: usize = 2;
+const IN_334: usize = 2;
+const OUT_334: usize = 1;
+fn aiur_fn_334(
+  inp: [G; IN_334],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_329], ExecError> {
+) -> Result<[G; OUT_334], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
-    let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     match __v_8.as_canonical_u64() {
       1u64 => {
         let __v_9: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_7.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_329] = [__v_1];
-            record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_334] = [__v_1];
+            record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __ret: [G; OUT_329] = [__v_0];
-            record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_334] = [__v_0];
+            record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -31014,8 +31202,8 @@ fn aiur_fn_329(
       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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_329] = [__v_10];
-        record.function_queries[329].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_334] = [__v_10];
+        record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31025,15 +31213,15 @@ fn aiur_fn_329(
   })
 }
 
-const INPUT_SIZE_330: usize = 1;
-const IN_330: usize = 1;
-const OUT_330: usize = 2;
-fn aiur_fn_330(
-  inp: [G; IN_330],
+const INPUT_SIZE_335: usize = 1;
+const IN_335: usize = 1;
+const OUT_335: usize = 2;
+fn aiur_fn_335(
+  inp: [G; IN_335],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_330], ExecError> {
+) -> Result<[G; OUT_335], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -31044,12 +31232,12 @@ fn aiur_fn_330(
       0u64 => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_330] = [__v_4, __v_5];
-        record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_335] = [__v_4, __v_5];
+        record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
         match __v_4.as_canonical_u64() {
@@ -31057,15 +31245,15 @@ fn aiur_fn_330(
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_5 + __v_7);
-            let __ret: [G; OUT_330] = [__v_6, __v_8];
-            record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_335] = [__v_6, __v_8];
+            record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(0);
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_330] = [__v_6, __v_7];
-            record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_335] = [__v_6, __v_7];
+            record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -31073,23 +31261,23 @@ fn aiur_fn_330(
       _ => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_330] = [__v_4, __v_5];
-        record.function_queries[330].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_335] = [__v_4, __v_5];
+        record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_331: usize = 2;
-const IN_331: usize = 2;
-const OUT_331: usize = 2;
-fn aiur_fn_331(
-  inp: [G; IN_331],
+const INPUT_SIZE_336: usize = 2;
+const IN_336: usize = 2;
+const OUT_336: usize = 2;
+fn aiur_fn_336(
+  inp: [G; IN_336],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_331], ExecError> {
+) -> Result<[G; OUT_336], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31101,31 +31289,31 @@ fn aiur_fn_331(
       1u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[331].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[331].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[331].bump_multiplicity(__i); } let __ret: [G; OUT_331] = unsafe { *(record.function_queries[331].output_at(__i).as_ptr() as *const [G; OUT_331]) }; __ret }, _ => aiur_fn_331(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __ret: [G; OUT_331] = [__v_7, __v_8];
-        record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_336] = [__v_7, __v_8];
+        record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_331] = [__v_0, __v_1];
-        record.function_queries[331].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_336] = [__v_0, __v_1];
+        record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_332: usize = 2;
-const IN_332: usize = 2;
-const OUT_332: usize = 1;
-fn aiur_fn_332(
-  inp: [G; IN_332],
+const INPUT_SIZE_337: usize = 2;
+const IN_337: usize = 2;
+const OUT_337: usize = 1;
+fn aiur_fn_337(
+  inp: [G; IN_337],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_332], ExecError> {
+) -> Result<[G; OUT_337], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31138,26 +31326,26 @@ fn aiur_fn_332(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_332] = [__v_7];
-        record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_337] = [__v_7];
+        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_332] = [__v_5];
-        record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_337] = [__v_5];
+        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_332] = [__v_6];
-            record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_337] = [__v_6];
+            record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -31167,24 +31355,24 @@ fn aiur_fn_332(
             let __v_8: G = __loaded[2];
             match __v_6.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_332] = [__v_1];
-                record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_337] = [__v_1];
+                record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[303].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[303].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[303].bump_multiplicity(__i); } let __ret: [G; OUT_303] = unsafe { *(record.function_queries[303].output_at(__i).as_ptr() as *const [G; OUT_303]) }; __ret }, _ => aiur_fn_303(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 match __v_9.as_canonical_u64() {
                   1u64 => {
-                    let __ret: [G; OUT_332] = [__v_0];
-                    record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_337] = [__v_0];
+                    record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
                     let __v_10: G = G::from_u64(3);
                     let __v_11: G = { let __values: [G; 3] = [__v_10, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_332] = [__v_11];
-                    record.function_queries[332].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_337] = [__v_11];
+                    record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -31203,15 +31391,15 @@ fn aiur_fn_332(
   })
 }
 
-const INPUT_SIZE_333: usize = 1;
-const IN_333: usize = 1;
-const OUT_333: usize = 1;
-fn aiur_fn_333(
-  inp: [G; IN_333],
+const INPUT_SIZE_338: usize = 1;
+const IN_338: usize = 1;
+const OUT_338: usize = 1;
+fn aiur_fn_338(
+  inp: [G; IN_338],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_333], ExecError> {
+) -> Result<[G; OUT_338], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -31223,48 +31411,48 @@ fn aiur_fn_333(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_6];
-        record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_338] = [__v_6];
+        record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_4: G = G::from_u64(4);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_2, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_6];
-        record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_338] = [__v_6];
+        record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_333] = [__v_7];
-        record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_338] = [__v_7];
+        record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_333] = [__v_6];
-        record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_338] = [__v_6];
+        record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_333] = [__v_6];
-        record.function_queries[333].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_338] = [__v_6];
+        record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31274,15 +31462,15 @@ fn aiur_fn_333(
   })
 }
 
-const INPUT_SIZE_334: usize = 2;
-const IN_334: usize = 2;
-const OUT_334: usize = 1;
-fn aiur_fn_334(
-  inp: [G; IN_334],
+const INPUT_SIZE_339: usize = 2;
+const IN_339: usize = 2;
+const OUT_339: usize = 1;
+fn aiur_fn_339(
+  inp: [G; IN_339],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_334], ExecError> {
+) -> Result<[G; OUT_339], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31295,47 +31483,47 @@ fn aiur_fn_334(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_334] = [__v_7];
-        record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_339] = [__v_7];
+        record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_334] = [__v_8];
-        record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_339] = [__v_8];
+        record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[325].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[325].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[325].bump_multiplicity(__i); } let __ret: [G; OUT_325] = unsafe { *(record.function_queries[325].output_at(__i).as_ptr() as *const [G; OUT_325]) }; __ret }, _ => aiur_fn_325(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[330].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[330].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[330].bump_multiplicity(__i); } let __ret: [G; OUT_330] = unsafe { *(record.function_queries[330].output_at(__i).as_ptr() as *const [G; OUT_330]) }; __ret }, _ => aiur_fn_330(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_334] = [__v_7];
-        record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_339] = [__v_7];
+        record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_334] = [__v_7];
-        record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_339] = [__v_7];
+        record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_334] = [__v_5];
-        record.function_queries[334].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_339] = [__v_5];
+        record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31345,15 +31533,15 @@ fn aiur_fn_334(
   })
 }
 
-const INPUT_SIZE_335: usize = 2;
-const IN_335: usize = 2;
-const OUT_335: usize = 1;
-fn aiur_fn_335(
-  inp: [G; IN_335],
+const INPUT_SIZE_340: usize = 2;
+const IN_340: usize = 2;
+const OUT_340: usize = 1;
+fn aiur_fn_340(
+  inp: [G; IN_340],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_335], ExecError> {
+) -> Result<[G; OUT_340], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31366,19 +31554,19 @@ fn aiur_fn_335(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_335] = [__v_7];
-        record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_340] = [__v_7];
+        record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_335] = [__v_8];
-        record.function_queries[335].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_340] = [__v_8];
+        record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31388,15 +31576,15 @@ fn aiur_fn_335(
   })
 }
 
-const INPUT_SIZE_336: usize = 2;
-const IN_336: usize = 2;
-const OUT_336: usize = 1;
-fn aiur_fn_336(
-  inp: [G; IN_336],
+const INPUT_SIZE_341: usize = 2;
+const IN_341: usize = 2;
+const OUT_341: usize = 1;
+fn aiur_fn_341(
+  inp: [G; IN_341],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_336], ExecError> {
+) -> Result<[G; OUT_341], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31406,30 +31594,30 @@ fn aiur_fn_336(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_336] = [__v_0];
-        record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_341] = [__v_0];
+        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[342].bump_multiplicity(__i); } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_336] = [__v_5];
-        record.function_queries[336].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_341] = [__v_5];
+        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_337: usize = 2;
-const IN_337: usize = 2;
-const OUT_337: usize = 1;
-fn aiur_fn_337(
-  inp: [G; IN_337],
+const INPUT_SIZE_342: usize = 2;
+const IN_342: usize = 2;
+const OUT_342: usize = 1;
+fn aiur_fn_342(
+  inp: [G; IN_342],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_337], ExecError> {
+) -> Result<[G; OUT_342], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31443,94 +31631,94 @@ fn aiur_fn_337(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_8];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_8];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[334].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[334].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[334].bump_multiplicity(__i); } let __ret: [G; OUT_334] = unsafe { *(record.function_queries[334].output_at(__i).as_ptr() as *const [G; OUT_334]) }; __ret }, _ => aiur_fn_334(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_9];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_9];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(2);
-        let __r_arr: [G; OUT_335] = { let __args: [G; IN_335] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[335].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[335].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[335].bump_multiplicity(__i); } let __ret: [G; OUT_335] = unsafe { *(record.function_queries[335].output_at(__i).as_ptr() as *const [G; OUT_335]) }; __ret }, _ => aiur_fn_335(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_9];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_9];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_6: G = G::from_u64(3);
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_10];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_10];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_6: G = G::from_u64(4);
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_10];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_10];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_6: G = G::from_u64(5);
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_10];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_10];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(6);
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_10];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_10];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(7);
         let __v_7: G = G::from_u64(0);
         let __v_8: G = { let __values: [G; 4] = [__v_6, __v_3, __v_4, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_8];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_8];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_6: G = G::from_u64(8);
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_337] = [__v_8];
-        record.function_queries[337].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_342] = [__v_8];
+        record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31540,15 +31728,15 @@ fn aiur_fn_337(
   })
 }
 
-const INPUT_SIZE_338: usize = 2;
-const IN_338: usize = 2;
-const OUT_338: usize = 1;
-fn aiur_fn_338(
-  inp: [G; IN_338],
+const INPUT_SIZE_343: usize = 2;
+const IN_343: usize = 2;
+const OUT_343: usize = 1;
+fn aiur_fn_343(
+  inp: [G; IN_343],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_338], ExecError> {
+) -> Result<[G; OUT_343], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31579,14 +31767,14 @@ fn aiur_fn_338(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(1);
-            let __ret: [G; OUT_338] = [__v_22];
-            record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_343] = [__v_22];
+            record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_338] = [__v_22];
-            record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_343] = [__v_22];
+            record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -31606,8 +31794,8 @@ fn aiur_fn_338(
         match __v_12.as_canonical_u64() {
           1u64 => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_338] = [__v_22];
-            record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_343] = [__v_22];
+            record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -31615,16 +31803,16 @@ fn aiur_fn_338(
             let __v_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_338] = [__v_23];
-                record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_343] = [__v_23];
+                record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_338] = [__v_23];
-                record.function_queries[338].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_343] = [__v_23];
+                record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -31644,15 +31832,15 @@ fn aiur_fn_338(
   })
 }
 
-const INPUT_SIZE_339: usize = 2;
-const IN_339: usize = 2;
-const OUT_339: usize = 1;
-fn aiur_fn_339(
-  inp: [G; IN_339],
+const INPUT_SIZE_344: usize = 2;
+const IN_344: usize = 2;
+const OUT_344: usize = 1;
+fn aiur_fn_344(
+  inp: [G; IN_344],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_339], ExecError> {
+) -> Result<[G; OUT_344], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31669,14 +31857,14 @@ fn aiur_fn_339(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_339] = [__v_8];
-            record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_344] = [__v_8];
+            record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_339] = [__v_8];
-            record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_344] = [__v_8];
+            record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -31689,24 +31877,24 @@ fn aiur_fn_339(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_339] = [__v_8];
-            record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_344] = [__v_8];
+            record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = (__v_3 - __v_6);
             match __v_8.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_339] = [__v_9];
-                record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_344] = [__v_9];
+                record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_339] = [__v_9];
-                record.function_queries[339].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_344] = [__v_9];
+                record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -31723,15 +31911,15 @@ fn aiur_fn_339(
   })
 }
 
-const INPUT_SIZE_340: usize = 4;
-const IN_340: usize = 4;
-const OUT_340: usize = 1;
-fn aiur_fn_340(
-  inp: [G; IN_340],
+const INPUT_SIZE_345: usize = 4;
+const IN_345: usize = 4;
+const OUT_345: usize = 1;
+fn aiur_fn_345(
+  inp: [G; IN_345],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_340], ExecError> {
+) -> Result<[G; OUT_345], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -31741,16 +31929,16 @@ fn aiur_fn_340(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_340] = [__v_4];
-            record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_345] = [__v_4];
+            record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_340] = [__v_4];
-            record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_345] = [__v_4];
+            record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -31758,16 +31946,16 @@ fn aiur_fn_340(
       1u64 => {
         match __v_2.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_340] = [__v_4];
-            record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_345] = [__v_4];
+            record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_340] = [__v_4];
-            record.function_queries[340].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_345] = [__v_4];
+            record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -31779,15 +31967,15 @@ fn aiur_fn_340(
   })
 }
 
-const INPUT_SIZE_341: usize = 1;
-const IN_341: usize = 1;
-const OUT_341: usize = 1;
-fn aiur_fn_341(
-  inp: [G; IN_341],
+const INPUT_SIZE_346: usize = 1;
+const IN_346: usize = 1;
+const OUT_346: usize = 1;
+fn aiur_fn_346(
+  inp: [G; IN_346],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_341], ExecError> {
+) -> Result<[G; OUT_346], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -31799,77 +31987,77 @@ fn aiur_fn_341(
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = (__v_2 + __v_5);
-        let __ret: [G; OUT_341] = [__v_6];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_6];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_341] = [__v_5];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_5];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_341] = [__v_5];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_5];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_341] = [__v_5];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_5];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_341] = [__v_7];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_7];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[349].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[349].bump_multiplicity(__i); } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => aiur_fn_349(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_341] = [__v_8];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_8];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[349].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[349].bump_multiplicity(__i); } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => aiur_fn_349(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_341] = [__v_8];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_8];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[342].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[342].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[342].bump_multiplicity(__i); } let __ret: [G; OUT_342] = unsafe { *(record.function_queries[342].output_at(__i).as_ptr() as *const [G; OUT_342]) }; __ret }, _ => aiur_fn_342(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i); } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_341] = [__v_5];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_5];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_341] = [__v_5];
-        record.function_queries[341].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_346] = [__v_5];
+        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31879,59 +32067,59 @@ fn aiur_fn_341(
   })
 }
 
-const INPUT_SIZE_342: usize = 3;
-const IN_342: usize = 3;
-const OUT_342: usize = 1;
-fn aiur_fn_342(
-  inp: [G; IN_342],
+const INPUT_SIZE_347: usize = 3;
+const IN_347: usize = 3;
+const OUT_347: usize = 1;
+fn aiur_fn_347(
+  inp: [G; IN_347],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_342], ExecError> {
+) -> Result<[G; OUT_347], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[349].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[349].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[349].bump_multiplicity(__i); } let __ret: [G; OUT_349] = unsafe { *(record.function_queries[349].output_at(__i).as_ptr() as *const [G; OUT_349]) }; __ret }, _ => aiur_fn_349(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_342] = [__v_8];
-    record.function_queries[342].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_347] = [__v_8];
+    record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_343: usize = 2;
-const IN_343: usize = 2;
-const OUT_343: usize = 1;
-fn aiur_fn_343(
-  inp: [G; IN_343],
+const INPUT_SIZE_348: usize = 2;
+const IN_348: usize = 2;
+const OUT_348: usize = 1;
+fn aiur_fn_348(
+  inp: [G; IN_348],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_343], ExecError> {
+) -> Result<[G; OUT_348], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_343] = [__v_1];
-        record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_348] = [__v_1];
+        record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_343] = [__v_0];
-        record.function_queries[343].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_348] = [__v_0];
+        record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -31941,57 +32129,57 @@ fn aiur_fn_343(
   })
 }
 
-const INPUT_SIZE_344: usize = 1;
-const IN_344: usize = 1;
-const OUT_344: usize = 1;
-fn aiur_fn_344(
-  inp: [G; IN_344],
+const INPUT_SIZE_349: usize = 1;
+const IN_349: usize = 1;
+const OUT_349: usize = 1;
+fn aiur_fn_349(
+  inp: [G; IN_349],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_344], ExecError> {
+) -> Result<[G; OUT_349], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_344] = [__v_1];
-        record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_349] = [__v_1];
+        record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_1: G = G::from_u64(1);
         let __v_2: G = (__v_0 - __v_1);
-        let __ret: [G; OUT_344] = [__v_2];
-        record.function_queries[344].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_349] = [__v_2];
+        record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_345: usize = 2;
-const IN_345: usize = 2;
-const OUT_345: usize = 1;
-fn aiur_fn_345(
-  inp: [G; IN_345],
+const INPUT_SIZE_350: usize = 2;
+const IN_350: usize = 2;
+const OUT_350: usize = 1;
+fn aiur_fn_350(
+  inp: [G; IN_350],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_345], ExecError> {
+) -> Result<[G; OUT_350], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_345] = [__v_0];
-        record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_350] = [__v_0];
+        record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_345] = [__v_1];
-        record.function_queries[345].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_350] = [__v_1];
+        record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32001,15 +32189,15 @@ fn aiur_fn_345(
   })
 }
 
-const INPUT_SIZE_346: usize = 3;
-const IN_346: usize = 3;
-const OUT_346: usize = 1;
-fn aiur_fn_346(
-  inp: [G; IN_346],
+const INPUT_SIZE_351: usize = 3;
+const IN_351: usize = 3;
+const OUT_351: usize = 1;
+fn aiur_fn_351(
+  inp: [G; IN_351],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_346], ExecError> {
+) -> Result<[G; OUT_351], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32025,14 +32213,14 @@ fn aiur_fn_346(
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_346] = [__v_8];
-            record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_351] = [__v_8];
+            record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_8: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
-            let __ret: [G; OUT_346] = [__v_8];
-            record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_351] = [__v_8];
+            record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32042,37 +32230,37 @@ fn aiur_fn_346(
       },
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_346] = [__v_8];
-            record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_351] = [__v_8];
+            record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_346] = [__v_8];
-            record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_351] = [__v_8];
+            record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32081,31 +32269,31 @@ fn aiur_fn_346(
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i); } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[347].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[347].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[347].bump_multiplicity(__i); } let __ret: [G; OUT_347] = unsafe { *(record.function_queries[347].output_at(__i).as_ptr() as *const [G; OUT_347]) }; __ret }, _ => aiur_fn_347(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_346] = [__v_7];
-        record.function_queries[346].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_351] = [__v_7];
+        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32115,27 +32303,27 @@ fn aiur_fn_346(
   })
 }
 
-const INPUT_SIZE_347: usize = 4;
-const IN_347: usize = 4;
-const OUT_347: usize = 1;
-fn aiur_fn_347(
-  inp: [G; IN_347],
+const INPUT_SIZE_352: usize = 4;
+const IN_352: usize = 4;
+const OUT_352: usize = 1;
+fn aiur_fn_352(
+  inp: [G; IN_352],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_347], ExecError> {
+) -> Result<[G; OUT_352], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_347] = [__v_5];
-        record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_352] = [__v_5];
+        record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -32143,10 +32331,10 @@ fn aiur_fn_347(
         let __v_6: G = (__v_2 + __v_5);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 + __v_7);
-        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_347] = [__v_9];
-        record.function_queries[347].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_352] = [__v_9];
+        record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32156,38 +32344,38 @@ fn aiur_fn_347(
   })
 }
 
-const INPUT_SIZE_348: usize = 5;
-const IN_348: usize = 5;
-const OUT_348: usize = 1;
-fn aiur_fn_348(
-  inp: [G; IN_348],
+const INPUT_SIZE_353: usize = 5;
+const IN_353: usize = 5;
+const OUT_353: usize = 1;
+fn aiur_fn_353(
+  inp: [G; IN_353],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_348], ExecError> {
+) -> Result<[G; OUT_353], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_348] = [__v_6];
-        record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_353] = [__v_6];
+        record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_348] = [__v_7];
-            record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_353] = [__v_7];
+            record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -32195,10 +32383,10 @@ fn aiur_fn_348(
             let __v_8: G = (__v_3 + __v_7);
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_4 + __v_9);
-            let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_2, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_348] = [__v_11];
-            record.function_queries[348].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_353] = [__v_11];
+            record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32213,60 +32401,60 @@ fn aiur_fn_348(
   })
 }
 
-const INPUT_SIZE_349: usize = 2;
-const IN_349: usize = 2;
-const OUT_349: usize = 1;
-fn aiur_fn_349(
-  inp: [G; IN_349],
+const INPUT_SIZE_354: usize = 2;
+const IN_354: usize = 2;
+const OUT_354: usize = 1;
+fn aiur_fn_354(
+  inp: [G; IN_354],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_349], ExecError> {
+) -> Result<[G; OUT_354], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_349] = [__v_4];
-    record.function_queries[349].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_354] = [__v_4];
+    record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_350: usize = 2;
-const IN_350: usize = 2;
-const OUT_350: usize = 1;
-fn aiur_fn_350(
-  inp: [G; IN_350],
+const INPUT_SIZE_355: usize = 2;
+const IN_355: usize = 2;
+const OUT_355: usize = 1;
+fn aiur_fn_355(
+  inp: [G; IN_355],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_350], ExecError> {
+) -> Result<[G; OUT_355], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_350] = [__v_2];
-        record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_355] = [__v_2];
+        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_350] = { let __args: [G; IN_350] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_2 + __v_6);
-        let __ret: [G; OUT_350] = [__v_7];
-        record.function_queries[350].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_355] = [__v_7];
+        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32276,15 +32464,15 @@ fn aiur_fn_350(
   })
 }
 
-const INPUT_SIZE_351: usize = 1;
-const IN_351: usize = 1;
-const OUT_351: usize = 1;
-fn aiur_fn_351(
-  inp: [G; IN_351],
+const INPUT_SIZE_356: usize = 1;
+const IN_356: usize = 1;
+const OUT_356: usize = 1;
+fn aiur_fn_356(
+  inp: [G; IN_356],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_351], ExecError> {
+) -> Result<[G; OUT_356], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -32294,13 +32482,13 @@ fn aiur_fn_351(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[357].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[357].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => aiur_fn_357(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_4 + __v_6);
-        let __ret: [G; OUT_351] = [__v_7];
-        record.function_queries[351].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_356] = [__v_7];
+        record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32310,44 +32498,44 @@ fn aiur_fn_351(
   })
 }
 
-const INPUT_SIZE_352: usize = 2;
-const IN_352: usize = 2;
-const OUT_352: usize = 1;
-fn aiur_fn_352(
-  inp: [G; IN_352],
+const INPUT_SIZE_357: usize = 2;
+const IN_357: usize = 2;
+const OUT_357: usize = 1;
+fn aiur_fn_357(
+  inp: [G; IN_357],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_352], ExecError> {
+) -> Result<[G; OUT_357], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(0);
-        let __ret: [G; OUT_352] = [__v_2];
-        record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_357] = [__v_2];
+        record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_352] = [__v_2];
-            record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_357] = [__v_2];
+            record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_352] = { let __args: [G; IN_352] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[352].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[352].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[352].bump_multiplicity(__i); } let __ret: [G; OUT_352] = unsafe { *(record.function_queries[352].output_at(__i).as_ptr() as *const [G; OUT_352]) }; __ret }, _ => aiur_fn_352(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[357].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[357].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => aiur_fn_357(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             let __v_7: G = (__v_2 + __v_6);
-            let __ret: [G; OUT_352] = [__v_7];
-            record.function_queries[352].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_357] = [__v_7];
+            record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32359,15 +32547,15 @@ fn aiur_fn_352(
   })
 }
 
-const INPUT_SIZE_353: usize = 2;
-const IN_353: usize = 2;
-const OUT_353: usize = 1;
-fn aiur_fn_353(
-  inp: [G; IN_353],
+const INPUT_SIZE_358: usize = 2;
+const IN_358: usize = 2;
+const OUT_358: usize = 1;
+fn aiur_fn_358(
+  inp: [G; IN_358],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_353], ExecError> {
+) -> Result<[G; OUT_358], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32376,31 +32564,31 @@ fn aiur_fn_353(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_353] = [__v_4];
-        record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_358] = [__v_4];
+        record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_3.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_353] = [__v_0];
-            record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_358] = [__v_0];
+            record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_353] = [__v_7];
-            record.function_queries[353].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_358] = [__v_7];
+            record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32412,19 +32600,19 @@ fn aiur_fn_353(
   })
 }
 
-const INPUT_SIZE_354: usize = 2;
-const IN_354: usize = 2;
-const OUT_354: usize = 1;
-fn aiur_fn_354(
-  inp: [G; IN_354],
+const INPUT_SIZE_359: usize = 2;
+const IN_359: usize = 2;
+const OUT_359: usize = 1;
+fn aiur_fn_359(
+  inp: [G; IN_359],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_354], ExecError> {
+) -> Result<[G; OUT_359], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__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);
@@ -32433,30 +32621,30 @@ fn aiur_fn_354(
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(4294967295);
-        let __ret: [G; OUT_354] = [__v_6];
-        record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_359] = [__v_6];
+        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[355].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[355].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[355].bump_multiplicity(__i); } let __ret: [G; OUT_355] = unsafe { *(record.function_queries[355].output_at(__i).as_ptr() as *const [G; OUT_355]) }; __ret }, _ => aiur_fn_355(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[360].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i); } let __ret: [G; OUT_360] = unsafe { *(record.function_queries[360].output_at(__i).as_ptr() as *const [G; OUT_360]) }; __ret }, _ => aiur_fn_360(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_354] = [__v_6];
-        record.function_queries[354].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_359] = [__v_6];
+        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_355: usize = 2;
-const IN_355: usize = 2;
-const OUT_355: usize = 1;
-fn aiur_fn_355(
-  inp: [G; IN_355],
+const INPUT_SIZE_360: usize = 2;
+const IN_360: usize = 2;
+const OUT_360: usize = 1;
+fn aiur_fn_360(
+  inp: [G; IN_360],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_355], ExecError> {
+) -> Result<[G; OUT_360], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32472,14 +32660,14 @@ fn aiur_fn_355(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(4294967295);
-            let __ret: [G; OUT_355] = [__v_7];
-            record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_360] = [__v_7];
+            record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_7: G = (__v_3 - __v_1);
-            let __ret: [G; OUT_355] = [__v_7];
-            record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_360] = [__v_7];
+            record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32489,71 +32677,71 @@ fn aiur_fn_355(
       },
       1u64 => {
         let __v_6: G = G::from_u64(4294967295);
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_6: G = G::from_u64(4294967295);
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_6: G = G::from_u64(4294967295);
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_355] = [__v_7];
-            record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_360] = [__v_7];
+            record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_355] = [__v_9];
-            record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_360] = [__v_9];
+            record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[356].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[356].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[356].bump_multiplicity(__i); } let __ret: [G; OUT_356] = unsafe { *(record.function_queries[356].output_at(__i).as_ptr() as *const [G; OUT_356]) }; __ret }, _ => aiur_fn_356(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[357].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[357].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[357].bump_multiplicity(__i); } let __ret: [G; OUT_357] = unsafe { *(record.function_queries[357].output_at(__i).as_ptr() as *const [G; OUT_357]) }; __ret }, _ => aiur_fn_357(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_355] = [__v_6];
-        record.function_queries[355].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_360] = [__v_6];
+        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32563,93 +32751,93 @@ fn aiur_fn_355(
   })
 }
 
-const INPUT_SIZE_356: usize = 3;
-const IN_356: usize = 3;
-const OUT_356: usize = 1;
-fn aiur_fn_356(
-  inp: [G; IN_356],
+const INPUT_SIZE_361: usize = 3;
+const IN_361: usize = 3;
+const OUT_361: usize = 1;
+fn aiur_fn_361(
+  inp: [G; IN_361],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_356], ExecError> {
+) -> Result<[G; OUT_361], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__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(0);
-        let __ret: [G; OUT_356] = [__v_4];
-        record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_361] = [__v_4];
+        record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__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_2 + __v_5);
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_356] = [__v_8];
-        record.function_queries[356].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_361] = [__v_8];
+        record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_357: usize = 4;
-const IN_357: usize = 4;
-const OUT_357: usize = 1;
-fn aiur_fn_357(
-  inp: [G; IN_357],
+const INPUT_SIZE_362: usize = 4;
+const IN_362: usize = 4;
+const OUT_362: usize = 1;
+fn aiur_fn_362(
+  inp: [G; IN_362],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_357], ExecError> {
+) -> Result<[G; OUT_362], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_357] = [__v_5];
-        record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_362] = [__v_5];
+        record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_357] = [__v_7];
-            record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_362] = [__v_7];
+            record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_3 + __v_9);
-            let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_357] = [__v_12];
-            record.function_queries[357].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_362] = [__v_12];
+            record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -32658,41 +32846,41 @@ fn aiur_fn_357(
   })
 }
 
-const INPUT_SIZE_358: usize = 3;
-const IN_358: usize = 3;
-const OUT_358: usize = 1;
-fn aiur_fn_358(
-  inp: [G; IN_358],
+const INPUT_SIZE_363: usize = 3;
+const IN_363: usize = 3;
+const OUT_363: usize = 1;
+fn aiur_fn_363(
+  inp: [G; IN_363],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_358], ExecError> {
+) -> Result<[G; OUT_363], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_358] = [__v_0];
-        record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_363] = [__v_0];
+        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_358] = [__v_0];
-            record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_363] = [__v_0];
+            record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_358] = [__v_5];
-            record.function_queries[358].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_363] = [__v_5];
+            record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32704,15 +32892,15 @@ fn aiur_fn_358(
   })
 }
 
-const INPUT_SIZE_359: usize = 3;
-const IN_359: usize = 3;
-const OUT_359: usize = 1;
-fn aiur_fn_359(
-  inp: [G; IN_359],
+const INPUT_SIZE_364: usize = 3;
+const IN_364: usize = 3;
+const OUT_364: usize = 1;
+fn aiur_fn_364(
+  inp: [G; IN_364],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_359], ExecError> {
+) -> Result<[G; OUT_364], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32724,90 +32912,90 @@ fn aiur_fn_359(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[360].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[360].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[360].bump_multiplicity(__i); } let __ret: [G; OUT_360] = unsafe { *(record.function_queries[360].output_at(__i).as_ptr() as *const [G; OUT_360]) }; __ret }, _ => aiur_fn_360(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[365].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => aiur_fn_365(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_359] = [__v_7];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_7];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_9];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_9];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_9];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_9];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_11];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_11];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_13];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_13];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_13];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_13];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[361].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[361].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[361].bump_multiplicity(__i); } let __ret: [G; OUT_361] = unsafe { *(record.function_queries[361].output_at(__i).as_ptr() as *const [G; OUT_361]) }; __ret }, _ => aiur_fn_361(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[366].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { *(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366]) }; __ret }, _ => aiur_fn_366(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_359] = [__v_7];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_7];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_9];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_9];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_359] = [__v_9];
-        record.function_queries[359].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_364] = [__v_9];
+        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32817,15 +33005,15 @@ fn aiur_fn_359(
   })
 }
 
-const INPUT_SIZE_360: usize = 3;
-const IN_360: usize = 3;
-const OUT_360: usize = 1;
-fn aiur_fn_360(
-  inp: [G; IN_360],
+const INPUT_SIZE_365: usize = 3;
+const IN_365: usize = 3;
+const OUT_365: usize = 1;
+fn aiur_fn_365(
+  inp: [G; IN_365],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_360], ExecError> {
+) -> Result<[G; OUT_365], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32836,8 +33024,8 @@ fn aiur_fn_360(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_360] = [__v_6];
-        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_365] = [__v_6];
+        record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -32845,8 +33033,8 @@ fn aiur_fn_360(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_360] = [__v_7];
-        record.function_queries[360].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_365] = [__v_7];
+        record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -32855,16 +33043,16 @@ fn aiur_fn_360(
     }
   })
 }
-
-const INPUT_SIZE_361: usize = 5;
-const IN_361: usize = 5;
-const OUT_361: usize = 1;
-fn aiur_fn_361(
-  inp: [G; IN_361],
+
+const INPUT_SIZE_366: usize = 5;
+const IN_366: usize = 5;
+const OUT_366: usize = 1;
+fn aiur_fn_366(
+  inp: [G; IN_366],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_361], ExecError> {
+) -> Result<[G; OUT_366], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32872,56 +33060,56 @@ fn aiur_fn_361(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_4 + __v_8);
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_361] = [__v_11];
-    record.function_queries[361].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_366] = [__v_11];
+    record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_362: usize = 3;
-const IN_362: usize = 3;
-const OUT_362: usize = 1;
-fn aiur_fn_362(
-  inp: [G; IN_362],
+const INPUT_SIZE_367: usize = 3;
+const IN_367: usize = 3;
+const OUT_367: usize = 1;
+fn aiur_fn_367(
+  inp: [G; IN_367],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_362], ExecError> {
+) -> Result<[G; OUT_367], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_362] = [__v_0];
-        record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_367] = [__v_0];
+        record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_362] = [__v_0];
-            record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_367] = [__v_0];
+            record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[368].bump_multiplicity(__i); } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_362] = [__v_5];
-            record.function_queries[362].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_367] = [__v_5];
+            record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32933,15 +33121,15 @@ fn aiur_fn_362(
   })
 }
 
-const INPUT_SIZE_363: usize = 3;
-const IN_363: usize = 3;
-const OUT_363: usize = 1;
-fn aiur_fn_363(
-  inp: [G; IN_363],
+const INPUT_SIZE_368: usize = 3;
+const IN_368: usize = 3;
+const OUT_368: usize = 1;
+fn aiur_fn_368(
+  inp: [G; IN_368],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_363], ExecError> {
+) -> Result<[G; OUT_368], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -32956,8 +33144,8 @@ fn aiur_fn_363(
         let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_363] = [__v_0];
-            record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_368] = [__v_0];
+            record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -32965,8 +33153,8 @@ fn aiur_fn_363(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_363] = [__v_11];
-            record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_368] = [__v_11];
+            record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -32978,88 +33166,88 @@ fn aiur_fn_363(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_9];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_9];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_9];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_9];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_11];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_11];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_13];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_13];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_13];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_13];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(6);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = G::from_u64(1);
         let __v_11: G = (__v_2 + __v_10);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_13];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_13];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_9];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_9];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_363] = [__v_9];
-        record.function_queries[363].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_368] = [__v_9];
+        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -33069,15 +33257,15 @@ fn aiur_fn_363(
   })
 }
 
-const INPUT_SIZE_364: usize = 2;
-const IN_364: usize = 2;
-const OUT_364: usize = 1;
-fn aiur_fn_364(
-  inp: [G; IN_364],
+const INPUT_SIZE_369: usize = 2;
+const IN_369: usize = 2;
+const OUT_369: usize = 1;
+fn aiur_fn_369(
+  inp: [G; IN_369],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_364], ExecError> {
+) -> Result<[G; OUT_369], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33092,150 +33280,150 @@ fn aiur_fn_364(
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_364] = [__v_7];
-            record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_369] = [__v_7];
+            record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_364] = [__v_7];
-            record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_369] = [__v_7];
+            record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       3u64 => {
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_364] = [__v_7];
-            record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_369] = [__v_7];
+            record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_364] = [__v_7];
-            record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_369] = [__v_7];
+            record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[365].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => aiur_fn_365(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[370].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[370].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[370].bump_multiplicity(__i); } let __ret: [G; OUT_370] = unsafe { *(record.function_queries[370].output_at(__i).as_ptr() as *const [G; OUT_370]) }; __ret }, _ => aiur_fn_370(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_364] = [__v_6];
-        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_369] = [__v_6];
+        record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[365].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[365].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[365].bump_multiplicity(__i); } let __ret: [G; OUT_365] = unsafe { *(record.function_queries[365].output_at(__i).as_ptr() as *const [G; OUT_365]) }; __ret }, _ => aiur_fn_365(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[370].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[370].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[370].bump_multiplicity(__i); } let __ret: [G; OUT_370] = unsafe { *(record.function_queries[370].output_at(__i).as_ptr() as *const [G; OUT_370]) }; __ret }, _ => aiur_fn_370(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_364] = [__v_6];
-        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_369] = [__v_6];
+        record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[366].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[366].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[366].bump_multiplicity(__i); } let __ret: [G; OUT_366] = unsafe { *(record.function_queries[366].output_at(__i).as_ptr() as *const [G; OUT_366]) }; __ret }, _ => aiur_fn_366(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_364] = [__v_6];
-        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_369] = [__v_6];
+        record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_364] = [__v_6];
-        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_369] = [__v_6];
+        record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_364] = [__v_6];
-        record.function_queries[364].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_369] = [__v_6];
+        record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_365: usize = 3;
-const IN_365: usize = 3;
-const OUT_365: usize = 1;
-fn aiur_fn_365(
-  inp: [G; IN_365],
+const INPUT_SIZE_370: usize = 3;
+const IN_370: usize = 3;
+const OUT_370: usize = 1;
+fn aiur_fn_370(
+  inp: [G; IN_370],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_365], ExecError> {
+) -> Result<[G; OUT_370], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_365] = [__v_4];
-        record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_370] = [__v_4];
+        record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_2 + __v_4);
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_365] = [__v_6];
-        record.function_queries[365].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_370] = [__v_6];
+        record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_366: usize = 4;
-const IN_366: usize = 4;
-const OUT_366: usize = 1;
-fn aiur_fn_366(
-  inp: [G; IN_366],
+const INPUT_SIZE_371: usize = 4;
+const IN_371: usize = 4;
+const OUT_371: usize = 1;
+fn aiur_fn_371(
+  inp: [G; IN_371],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_366], ExecError> {
+) -> Result<[G; OUT_371], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_366] = [__v_5];
-        record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_371] = [__v_5];
+        record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_366] = [__v_6];
-            record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_371] = [__v_6];
+            record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_3 + __v_6);
-            let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_366] = [__v_8];
-            record.function_queries[366].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_371] = [__v_8];
+            record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -33244,48 +33432,48 @@ fn aiur_fn_366(
   })
 }
 
-const INPUT_SIZE_367: usize = 3;
-const IN_367: usize = 3;
-const OUT_367: usize = 1;
-fn aiur_fn_367(
-  inp: [G; IN_367],
+const INPUT_SIZE_372: usize = 3;
+const IN_372: usize = 3;
+const OUT_372: usize = 1;
+fn aiur_fn_372(
+  inp: [G; IN_372],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_367], ExecError> {
+) -> Result<[G; OUT_372], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_367] = [__v_0];
-        record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_372] = [__v_0];
+        record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[364].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[364].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[364].bump_multiplicity(__i); } let __ret: [G; OUT_364] = unsafe { *(record.function_queries[364].output_at(__i).as_ptr() as *const [G; OUT_364]) }; __ret }, _ => aiur_fn_364(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[368].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[368].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[368].bump_multiplicity(__i); } let __ret: [G; OUT_368] = unsafe { *(record.function_queries[368].output_at(__i).as_ptr() as *const [G; OUT_368]) }; __ret }, _ => aiur_fn_368(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[373].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => aiur_fn_373(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_367] = [__v_6];
-            record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_372] = [__v_6];
+            record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_2 + __v_7);
-            let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_367] = [__v_9];
-            record.function_queries[367].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_372] = [__v_9];
+            record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -33297,15 +33485,15 @@ fn aiur_fn_367(
   })
 }
 
-const INPUT_SIZE_368: usize = 3;
-const IN_368: usize = 3;
-const OUT_368: usize = 1;
-fn aiur_fn_368(
-  inp: [G; IN_368],
+const INPUT_SIZE_373: usize = 3;
+const IN_373: usize = 3;
+const OUT_373: usize = 1;
+fn aiur_fn_373(
+  inp: [G; IN_373],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_368], ExecError> {
+) -> Result<[G; OUT_373], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33317,90 +33505,90 @@ fn aiur_fn_368(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[369].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[369].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[369].bump_multiplicity(__i); } let __ret: [G; OUT_369] = unsafe { *(record.function_queries[369].output_at(__i).as_ptr() as *const [G; OUT_369]) }; __ret }, _ => aiur_fn_369(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_368] = [__v_7];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_7];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_9];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_9];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_9];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_9];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_11];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_11];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_13];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_13];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_13];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_13];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[370].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[370].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[370].bump_multiplicity(__i); } let __ret: [G; OUT_370] = unsafe { *(record.function_queries[370].output_at(__i).as_ptr() as *const [G; OUT_370]) }; __ret }, _ => aiur_fn_370(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_368] = [__v_7];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_7];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_9];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_9];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_368] = [__v_9];
-        record.function_queries[368].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_373] = [__v_9];
+        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -33410,15 +33598,15 @@ fn aiur_fn_368(
   })
 }
 
-const INPUT_SIZE_369: usize = 3;
-const IN_369: usize = 3;
-const OUT_369: usize = 1;
-fn aiur_fn_369(
-  inp: [G; IN_369],
+const INPUT_SIZE_374: usize = 3;
+const IN_374: usize = 3;
+const OUT_374: usize = 1;
+fn aiur_fn_374(
+  inp: [G; IN_374],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_369], ExecError> {
+) -> Result<[G; OUT_374], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33430,8 +33618,8 @@ fn aiur_fn_369(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_369] = [__v_6];
-        record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_374] = [__v_6];
+        record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -33439,10 +33627,10 @@ fn aiur_fn_369(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(0);
-            let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_369] = [__v_6];
-            record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_374] = [__v_6];
+            record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -33451,8 +33639,8 @@ fn aiur_fn_369(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_369] = [__v_9];
-            record.function_queries[369].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_374] = [__v_9];
+            record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -33464,15 +33652,15 @@ fn aiur_fn_369(
   })
 }
 
-const INPUT_SIZE_370: usize = 5;
-const IN_370: usize = 5;
-const OUT_370: usize = 1;
-fn aiur_fn_370(
-  inp: [G; IN_370],
+const INPUT_SIZE_375: usize = 5;
+const IN_375: usize = 5;
+const OUT_375: usize = 1;
+fn aiur_fn_375(
+  inp: [G; IN_375],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_370], ExecError> {
+) -> Result<[G; OUT_375], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33480,71 +33668,71 @@ fn aiur_fn_370(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_4 + __v_8);
-    let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_370] = [__v_11];
-    record.function_queries[370].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_375] = [__v_11];
+    record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_371: usize = 3;
-const IN_371: usize = 3;
-const OUT_371: usize = 1;
-fn aiur_fn_371(
-  inp: [G; IN_371],
+const INPUT_SIZE_376: usize = 3;
+const IN_376: usize = 3;
+const OUT_376: usize = 1;
+fn aiur_fn_376(
+  inp: [G; IN_376],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_371], ExecError> {
+) -> Result<[G; OUT_376], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_371] = [__v_0];
-        record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_376] = [__v_0];
+        record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_371] = [__v_0];
-            record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_376] = [__v_0];
+            record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_6: G = (__v_2 + __v_3);
-            let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[373].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[373].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[373].bump_multiplicity(__i); } let __ret: [G; OUT_373] = unsafe { *(record.function_queries[373].output_at(__i).as_ptr() as *const [G; OUT_373]) }; __ret }, _ => aiur_fn_373(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[378].bump_multiplicity(__i); } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
-                let __ret: [G; OUT_371] = [__v_8];
-                record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_376] = [__v_8];
+                record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_8: G = (__v_2 + __v_3);
-                let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_371] = [__v_9];
-                record.function_queries[371].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_376] = [__v_9];
+                record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -33558,33 +33746,33 @@ fn aiur_fn_371(
   })
 }
 
-const INPUT_SIZE_372: usize = 3;
-const IN_372: usize = 3;
-const OUT_372: usize = 1;
-fn aiur_fn_372(
-  inp: [G; IN_372],
+const INPUT_SIZE_377: usize = 3;
+const IN_377: usize = 3;
+const OUT_377: usize = 1;
+fn aiur_fn_377(
+  inp: [G; IN_377],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_372], ExecError> {
+) -> Result<[G; OUT_377], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_0] = { let __args: [G; IN_0] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_358] = { let __args: [G; IN_358] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_372] = [__v_8];
-        record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_377] = [__v_8];
+        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -33592,8 +33780,8 @@ fn aiur_fn_372(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_372] = [__v_9];
-        record.function_queries[372].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_377] = [__v_9];
+        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -33603,15 +33791,15 @@ fn aiur_fn_372(
   })
 }
 
-const INPUT_SIZE_373: usize = 3;
-const IN_373: usize = 3;
-const OUT_373: usize = 1;
-fn aiur_fn_373(
-  inp: [G; IN_373],
+const INPUT_SIZE_378: usize = 3;
+const IN_378: usize = 3;
+const OUT_378: usize = 1;
+fn aiur_fn_378(
+  inp: [G; IN_378],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_373], ExecError> {
+) -> Result<[G; OUT_378], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33623,90 +33811,90 @@ fn aiur_fn_373(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_373] = [__v_7];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_9];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_9];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_7: G = G::from_u64(2);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_9];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_9];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_7: G = G::from_u64(3);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_11];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_11];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_7: G = G::from_u64(4);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_13];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_13];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_7: G = G::from_u64(5);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         let __v_10: G = (__v_2 + __v_9);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_13];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_13];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[374].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[374].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[374].bump_multiplicity(__i); } let __ret: [G; OUT_374] = unsafe { *(record.function_queries[374].output_at(__i).as_ptr() as *const [G; OUT_374]) }; __ret }, _ => aiur_fn_374(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[379].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => aiur_fn_379(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_373] = [__v_7];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_7];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_7: G = G::from_u64(7);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_9];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_9];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
         let __v_7: G = G::from_u64(8);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_373] = [__v_9];
-        record.function_queries[373].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_378] = [__v_9];
+        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -33716,15 +33904,15 @@ fn aiur_fn_373(
   })
 }
 
-const INPUT_SIZE_374: usize = 5;
-const IN_374: usize = 5;
-const OUT_374: usize = 1;
-fn aiur_fn_374(
-  inp: [G; IN_374],
+const INPUT_SIZE_379: usize = 5;
+const IN_379: usize = 5;
+const OUT_379: usize = 1;
+fn aiur_fn_379(
+  inp: [G; IN_379],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_374], ExecError> {
+) -> Result<[G; OUT_379], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33732,30 +33920,30 @@ fn aiur_fn_374(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(6);
-    let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     let __v_9: G = (__v_4 + __v_8);
-    let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_2, __v_3, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_374] = [__v_11];
-    record.function_queries[374].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_379] = [__v_11];
+    record.function_queries[379].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_375: usize = 3;
-const IN_375: usize = 3;
-const OUT_375: usize = 3;
-fn aiur_fn_375(
-  inp: [G; IN_375],
+const INPUT_SIZE_380: usize = 3;
+const IN_380: usize = 3;
+const OUT_380: usize = 3;
+fn aiur_fn_380(
+  inp: [G; IN_380],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_375], ExecError> {
+) -> Result<[G; OUT_380], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33775,17 +33963,17 @@ fn aiur_fn_375(
           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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__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_375] = [__v_12, __v_13, __v_14];
-            record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_380] = [__v_12, __v_13, __v_14];
+            record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1];
-            record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_380] = [__v_0, __v_2, __v_1];
+            record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -33794,23 +33982,23 @@ fn aiur_fn_375(
         }
       },
       _ => {
-        let __ret: [G; OUT_375] = [__v_0, __v_2, __v_1];
-        record.function_queries[375].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_380] = [__v_0, __v_2, __v_1];
+        record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_376: usize = 3;
-const IN_376: usize = 3;
-const OUT_376: usize = 1;
-fn aiur_fn_376(
-  inp: [G; IN_376],
+const INPUT_SIZE_381: usize = 3;
+const IN_381: usize = 3;
+const OUT_381: usize = 1;
+fn aiur_fn_381(
+  inp: [G; IN_381],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_376], ExecError> {
+) -> Result<[G; OUT_381], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33818,56 +34006,56 @@ fn aiur_fn_376(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__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_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_376] = [__v_10];
-        record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_381] = [__v_10];
+        record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_376] = [__v_14];
-        record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_381] = [__v_14];
+        record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_376] = [__v_12];
-        record.function_queries[376].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_381] = [__v_12];
+        record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_377: usize = 3;
-const IN_377: usize = 3;
-const OUT_377: usize = 1;
-fn aiur_fn_377(
-  inp: [G; IN_377],
+const INPUT_SIZE_382: usize = 3;
+const IN_382: usize = 3;
+const OUT_382: usize = 1;
+fn aiur_fn_382(
+  inp: [G; IN_382],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_377], ExecError> {
+) -> Result<[G; OUT_382], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -33879,90 +34067,90 @@ fn aiur_fn_377(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_377] = [__v_10];
-        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_382] = [__v_10];
+        record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_377] = [__v_7];
-        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_382] = [__v_7];
+        record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i); } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => aiur_fn_401(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_377] = [__v_7];
-        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_382] = [__v_7];
+        record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_377] = [__v_9];
-        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_382] = [__v_9];
+        record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[378].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[378].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[378].bump_multiplicity(__i); } let __ret: [G; OUT_378] = unsafe { *(record.function_queries[378].output_at(__i).as_ptr() as *const [G; OUT_378]) }; __ret }, _ => aiur_fn_378(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_377] = [__v_7];
-        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_382] = [__v_7];
+        record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_377] = [__v_7];
-        record.function_queries[377].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_382] = [__v_7];
+        record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_378: usize = 5;
-const IN_378: usize = 5;
-const OUT_378: usize = 1;
-fn aiur_fn_378(
-  inp: [G; IN_378],
+const INPUT_SIZE_383: usize = 5;
+const IN_383: usize = 5;
+const OUT_383: usize = 1;
+fn aiur_fn_383(
+  inp: [G; IN_383],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_378], ExecError> {
+) -> Result<[G; OUT_383], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[385].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => aiur_fn_385(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_378] = [__v_11];
-        record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_383] = [__v_11];
+        record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -33973,7 +34161,7 @@ fn aiur_fn_378(
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_16: G = __loaded[0];
@@ -33991,21 +34179,21 @@ fn aiur_fn_378(
             match __v_16.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_378] = [__v_30];
-                record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_383] = [__v_30];
+                record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_28: G = G::from_u64(8);
                 let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_378] = [__v_30];
-                record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_383] = [__v_30];
+                record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -34013,10 +34201,10 @@ fn aiur_fn_378(
           _ => {
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_378] = [__v_17];
-            record.function_queries[378].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_383] = [__v_17];
+            record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -34025,315 +34213,315 @@ fn aiur_fn_378(
   })
 }
 
-const INPUT_SIZE_379: usize = 0;
-const IN_379: usize = 0;
-const OUT_379: usize = 1;
-fn aiur_fn_379(
-  inp: [G; IN_379],
+const INPUT_SIZE_384: usize = 0;
+const IN_384: usize = 0;
+const OUT_384: usize = 1;
+fn aiur_fn_384(
+  inp: [G; IN_384],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_379], ExecError> {
+) -> Result<[G; OUT_384], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(167);
-    let __v_1: G = G::from_u64(233);
-    let __v_2: G = G::from_u64(168);
-    let __v_3: G = G::from_u64(184);
-    let __v_4: G = G::from_u64(74);
-    let __v_5: G = G::from_u64(47);
-    let __v_6: G = G::from_u64(233);
-    let __v_7: G = G::from_u64(108);
-    let __v_8: G = G::from_u64(194);
-    let __v_9: G = G::from_u64(4);
-    let __v_10: G = G::from_u64(172);
-    let __v_11: G = G::from_u64(201);
-    let __v_12: G = G::from_u64(61);
-    let __v_13: G = G::from_u64(126);
-    let __v_14: G = G::from_u64(209);
-    let __v_15: G = G::from_u64(54);
-    let __v_16: G = G::from_u64(109);
-    let __v_17: G = G::from_u64(157);
-    let __v_18: G = G::from_u64(5);
-    let __v_19: G = G::from_u64(116);
-    let __v_20: G = G::from_u64(170);
-    let __v_21: G = G::from_u64(240);
-    let __v_22: G = G::from_u64(240);
-    let __v_23: G = G::from_u64(150);
-    let __v_24: G = G::from_u64(51);
-    let __v_25: G = G::from_u64(210);
-    let __v_26: G = G::from_u64(176);
-    let __v_27: G = G::from_u64(154);
-    let __v_28: G = G::from_u64(148);
-    let __v_29: G = G::from_u64(201);
-    let __v_30: G = G::from_u64(232);
-    let __v_31: G = G::from_u64(96);
+    let __v_0: G = G::from_u64(61);
+    let __v_1: G = G::from_u64(121);
+    let __v_2: G = G::from_u64(121);
+    let __v_3: G = G::from_u64(123);
+    let __v_4: G = G::from_u64(197);
+    let __v_5: G = G::from_u64(114);
+    let __v_6: G = G::from_u64(216);
+    let __v_7: G = G::from_u64(243);
+    let __v_8: G = G::from_u64(62);
+    let __v_9: G = G::from_u64(183);
+    let __v_10: G = G::from_u64(207);
+    let __v_11: G = G::from_u64(245);
+    let __v_12: G = G::from_u64(170);
+    let __v_13: G = G::from_u64(19);
+    let __v_14: G = G::from_u64(248);
+    let __v_15: G = G::from_u64(220);
+    let __v_16: G = G::from_u64(115);
+    let __v_17: G = G::from_u64(188);
+    let __v_18: G = G::from_u64(242);
+    let __v_19: G = G::from_u64(16);
+    let __v_20: G = G::from_u64(38);
+    let __v_21: G = G::from_u64(191);
+    let __v_22: G = G::from_u64(5);
+    let __v_23: G = G::from_u64(208);
+    let __v_24: G = G::from_u64(56);
+    let __v_25: G = G::from_u64(136);
+    let __v_26: G = G::from_u64(201);
+    let __v_27: G = G::from_u64(170);
+    let __v_28: G = G::from_u64(3);
+    let __v_29: G = G::from_u64(105);
+    let __v_30: G = G::from_u64(220);
+    let __v_31: G = G::from_u64(239);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_379] = [__v_32];
-    record.function_queries[379].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_384] = [__v_32];
+    record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_380: usize = 0;
-const IN_380: usize = 0;
-const OUT_380: usize = 1;
-fn aiur_fn_380(
-  inp: [G; IN_380],
+const INPUT_SIZE_385: usize = 0;
+const IN_385: usize = 0;
+const OUT_385: usize = 1;
+fn aiur_fn_385(
+  inp: [G; IN_385],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_380], ExecError> {
+) -> Result<[G; OUT_385], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(106);
-    let __v_1: G = G::from_u64(247);
-    let __v_2: G = G::from_u64(56);
-    let __v_3: G = G::from_u64(9);
-    let __v_4: G = G::from_u64(166);
-    let __v_5: G = G::from_u64(18);
-    let __v_6: G = G::from_u64(138);
-    let __v_7: G = G::from_u64(220);
-    let __v_8: G = G::from_u64(185);
-    let __v_9: G = G::from_u64(197);
-    let __v_10: G = G::from_u64(215);
-    let __v_11: G = G::from_u64(231);
-    let __v_12: G = G::from_u64(58);
-    let __v_13: G = G::from_u64(48);
-    let __v_14: G = G::from_u64(194);
-    let __v_15: G = G::from_u64(141);
-    let __v_16: G = G::from_u64(72);
-    let __v_17: G = G::from_u64(157);
-    let __v_18: G = G::from_u64(186);
-    let __v_19: G = G::from_u64(77);
-    let __v_20: G = G::from_u64(144);
-    let __v_21: G = G::from_u64(87);
-    let __v_22: G = G::from_u64(23);
-    let __v_23: G = G::from_u64(5);
-    let __v_24: G = G::from_u64(90);
-    let __v_25: G = G::from_u64(194);
-    let __v_26: G = G::from_u64(237);
-    let __v_27: G = G::from_u64(215);
-    let __v_28: G = G::from_u64(85);
-    let __v_29: G = G::from_u64(255);
-    let __v_30: G = G::from_u64(167);
-    let __v_31: G = G::from_u64(19);
+    let __v_0: G = G::from_u64(22);
+    let __v_1: G = G::from_u64(207);
+    let __v_2: G = G::from_u64(221);
+    let __v_3: G = G::from_u64(218);
+    let __v_4: G = G::from_u64(156);
+    let __v_5: G = G::from_u64(39);
+    let __v_6: G = G::from_u64(70);
+    let __v_7: G = G::from_u64(96);
+    let __v_8: G = G::from_u64(243);
+    let __v_9: G = G::from_u64(145);
+    let __v_10: G = G::from_u64(177);
+    let __v_11: G = G::from_u64(14);
+    let __v_12: G = G::from_u64(239);
+    let __v_13: G = G::from_u64(224);
+    let __v_14: G = G::from_u64(102);
+    let __v_15: G = G::from_u64(39);
+    let __v_16: G = G::from_u64(90);
+    let __v_17: G = G::from_u64(255);
+    let __v_18: G = G::from_u64(250);
+    let __v_19: G = G::from_u64(225);
+    let __v_20: G = G::from_u64(204);
+    let __v_21: G = G::from_u64(212);
+    let __v_22: G = G::from_u64(156);
+    let __v_23: G = G::from_u64(109);
+    let __v_24: G = G::from_u64(175);
+    let __v_25: G = G::from_u64(67);
+    let __v_26: G = G::from_u64(175);
+    let __v_27: G = G::from_u64(184);
+    let __v_28: G = G::from_u64(168);
+    let __v_29: G = G::from_u64(10);
+    let __v_30: G = G::from_u64(234);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_380] = [__v_32];
-    record.function_queries[380].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_385] = [__v_32];
+    record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_381: usize = 0;
-const IN_381: usize = 0;
-const OUT_381: usize = 1;
-fn aiur_fn_381(
-  inp: [G; IN_381],
+const INPUT_SIZE_386: usize = 0;
+const IN_386: usize = 0;
+const OUT_386: usize = 1;
+fn aiur_fn_386(
+  inp: [G; IN_386],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_381], ExecError> {
+) -> Result<[G; OUT_386], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(29);
-    let __v_1: G = G::from_u64(255);
-    let __v_2: G = G::from_u64(253);
-    let __v_3: G = G::from_u64(228);
-    let __v_4: G = G::from_u64(140);
-    let __v_5: G = G::from_u64(78);
-    let __v_6: G = G::from_u64(246);
+    let __v_0: G = G::from_u64(53);
+    let __v_1: G = G::from_u64(225);
+    let __v_2: G = G::from_u64(204);
+    let __v_3: G = G::from_u64(128);
+    let __v_4: G = G::from_u64(159);
+    let __v_5: G = G::from_u64(111);
+    let __v_6: G = G::from_u64(7);
     let __v_7: G = G::from_u64(101);
-    let __v_8: G = G::from_u64(59);
-    let __v_9: G = G::from_u64(149);
-    let __v_10: G = G::from_u64(236);
-    let __v_11: G = G::from_u64(197);
-    let __v_12: G = G::from_u64(71);
-    let __v_13: G = G::from_u64(77);
-    let __v_14: G = G::from_u64(238);
-    let __v_15: G = G::from_u64(139);
-    let __v_16: G = G::from_u64(153);
-    let __v_17: G = G::from_u64(70);
-    let __v_18: G = G::from_u64(16);
-    let __v_19: G = G::from_u64(8);
-    let __v_20: G = G::from_u64(210);
-    let __v_21: G = G::from_u64(109);
-    let __v_22: G = G::from_u64(128);
-    let __v_23: G = G::from_u64(202);
-    let __v_24: G = G::from_u64(56);
-    let __v_25: G = G::from_u64(79);
-    let __v_26: G = G::from_u64(30);
-    let __v_27: G = G::from_u64(89);
-    let __v_28: G = G::from_u64(233);
-    let __v_29: G = G::from_u64(39);
-    let __v_30: G = G::from_u64(113);
-    let __v_31: G = G::from_u64(77);
+    let __v_8: G = G::from_u64(33);
+    let __v_9: G = G::from_u64(164);
+    let __v_10: G = G::from_u64(63);
+    let __v_11: G = G::from_u64(133);
+    let __v_12: G = G::from_u64(6);
+    let __v_13: G = G::from_u64(141);
+    let __v_14: G = G::from_u64(85);
+    let __v_15: G = G::from_u64(146);
+    let __v_16: G = G::from_u64(34);
+    let __v_17: G = G::from_u64(4);
+    let __v_18: G = G::from_u64(7);
+    let __v_19: G = G::from_u64(192);
+    let __v_20: G = G::from_u64(83);
+    let __v_21: G = G::from_u64(43);
+    let __v_22: G = G::from_u64(106);
+    let __v_23: G = G::from_u64(8);
+    let __v_24: G = G::from_u64(149);
+    let __v_25: G = G::from_u64(47);
+    let __v_26: G = G::from_u64(64);
+    let __v_27: G = G::from_u64(216);
+    let __v_28: G = G::from_u64(82);
+    let __v_29: G = G::from_u64(61);
+    let __v_30: G = G::from_u64(4);
+    let __v_31: G = G::from_u64(188);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_381] = [__v_32];
-    record.function_queries[381].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_386] = [__v_32];
+    record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_382: usize = 0;
-const IN_382: usize = 0;
-const OUT_382: usize = 1;
-fn aiur_fn_382(
-  inp: [G; IN_382],
+const INPUT_SIZE_387: usize = 0;
+const IN_387: usize = 0;
+const OUT_387: usize = 1;
+fn aiur_fn_387(
+  inp: [G; IN_387],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_382], ExecError> {
+) -> Result<[G; OUT_387], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(10);
-    let __v_1: G = G::from_u64(76);
-    let __v_2: G = G::from_u64(199);
-    let __v_3: G = G::from_u64(201);
-    let __v_4: G = G::from_u64(48);
-    let __v_5: G = G::from_u64(221);
-    let __v_6: G = G::from_u64(103);
-    let __v_7: G = G::from_u64(38);
-    let __v_8: G = G::from_u64(187);
-    let __v_9: G = G::from_u64(215);
-    let __v_10: G = G::from_u64(241);
-    let __v_11: G = G::from_u64(188);
-    let __v_12: G = G::from_u64(63);
-    let __v_13: G = G::from_u64(234);
-    let __v_14: G = G::from_u64(104);
-    let __v_15: G = G::from_u64(93);
-    let __v_16: G = G::from_u64(245);
-    let __v_17: G = G::from_u64(246);
-    let __v_18: G = G::from_u64(102);
-    let __v_19: G = G::from_u64(84);
-    let __v_20: G = G::from_u64(157);
-    let __v_21: G = G::from_u64(101);
-    let __v_22: G = G::from_u64(29);
-    let __v_23: G = G::from_u64(62);
-    let __v_24: G = G::from_u64(118);
-    let __v_25: G = G::from_u64(111);
-    let __v_26: G = G::from_u64(229);
-    let __v_27: G = G::from_u64(116);
-    let __v_28: G = G::from_u64(110);
-    let __v_29: G = G::from_u64(196);
-    let __v_30: G = G::from_u64(89);
-    let __v_31: G = G::from_u64(164);
+    let __v_0: G = G::from_u64(129);
+    let __v_1: G = G::from_u64(22);
+    let __v_2: G = G::from_u64(0);
+    let __v_3: G = G::from_u64(223);
+    let __v_4: G = G::from_u64(165);
+    let __v_5: G = G::from_u64(159);
+    let __v_6: G = G::from_u64(54);
+    let __v_7: G = G::from_u64(18);
+    let __v_8: G = G::from_u64(203);
+    let __v_9: G = G::from_u64(3);
+    let __v_10: G = G::from_u64(192);
+    let __v_11: G = G::from_u64(240);
+    let __v_12: G = G::from_u64(71);
+    let __v_13: G = G::from_u64(90);
+    let __v_14: G = G::from_u64(241);
+    let __v_15: G = G::from_u64(82);
+    let __v_16: G = G::from_u64(57);
+    let __v_17: G = G::from_u64(157);
+    let __v_18: G = G::from_u64(239);
+    let __v_19: G = G::from_u64(255);
+    let __v_20: G = G::from_u64(146);
+    let __v_21: G = G::from_u64(38);
+    let __v_22: G = G::from_u64(198);
+    let __v_23: G = G::from_u64(225);
+    let __v_24: G = G::from_u64(159);
+    let __v_25: G = G::from_u64(214);
+    let __v_26: G = G::from_u64(72);
+    let __v_27: G = G::from_u64(4);
+    let __v_28: G = G::from_u64(26);
+    let __v_29: G = G::from_u64(104);
+    let __v_30: G = G::from_u64(153);
+    let __v_31: G = G::from_u64(169);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_382] = [__v_32];
-    record.function_queries[382].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_387] = [__v_32];
+    record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_383: usize = 0;
-const IN_383: usize = 0;
-const OUT_383: usize = 1;
-fn aiur_fn_383(
-  inp: [G; IN_383],
+const INPUT_SIZE_388: usize = 0;
+const IN_388: usize = 0;
+const OUT_388: usize = 1;
+fn aiur_fn_388(
+  inp: [G; IN_388],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_383], ExecError> {
+) -> Result<[G; OUT_388], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(86);
-    let __v_1: G = G::from_u64(2);
-    let __v_2: G = G::from_u64(118);
-    let __v_3: G = G::from_u64(249);
-    let __v_4: G = G::from_u64(94);
-    let __v_5: G = G::from_u64(13);
-    let __v_6: G = G::from_u64(147);
-    let __v_7: G = G::from_u64(226);
-    let __v_8: G = G::from_u64(123);
-    let __v_9: G = G::from_u64(140);
-    let __v_10: G = G::from_u64(5);
-    let __v_11: G = G::from_u64(9);
-    let __v_12: G = G::from_u64(121);
-    let __v_13: G = G::from_u64(149);
-    let __v_14: G = G::from_u64(191);
-    let __v_15: G = G::from_u64(130);
-    let __v_16: G = G::from_u64(135);
-    let __v_17: G = G::from_u64(99);
-    let __v_18: G = G::from_u64(50);
-    let __v_19: G = G::from_u64(194);
-    let __v_20: G = G::from_u64(231);
-    let __v_21: G = G::from_u64(227);
-    let __v_22: G = G::from_u64(16);
-    let __v_23: G = G::from_u64(51);
-    let __v_24: G = G::from_u64(224);
-    let __v_25: G = G::from_u64(161);
-    let __v_26: G = G::from_u64(148);
-    let __v_27: G = G::from_u64(129);
-    let __v_28: G = G::from_u64(158);
-    let __v_29: G = G::from_u64(78);
-    let __v_30: G = G::from_u64(141);
-    let __v_31: G = G::from_u64(48);
+    let __v_0: G = G::from_u64(134);
+    let __v_1: G = G::from_u64(179);
+    let __v_2: G = G::from_u64(101);
+    let __v_3: G = G::from_u64(231);
+    let __v_4: G = G::from_u64(91);
+    let __v_5: G = G::from_u64(180);
+    let __v_6: G = G::from_u64(35);
+    let __v_7: G = G::from_u64(15);
+    let __v_8: G = G::from_u64(4);
+    let __v_9: G = G::from_u64(198);
+    let __v_10: G = G::from_u64(228);
+    let __v_11: G = G::from_u64(243);
+    let __v_12: G = G::from_u64(167);
+    let __v_13: G = G::from_u64(202);
+    let __v_14: G = G::from_u64(105);
+    let __v_15: G = G::from_u64(136);
+    let __v_16: G = G::from_u64(173);
+    let __v_17: G = G::from_u64(245);
+    let __v_18: G = G::from_u64(116);
+    let __v_19: G = G::from_u64(97);
+    let __v_20: G = G::from_u64(109);
+    let __v_21: G = G::from_u64(121);
+    let __v_22: G = G::from_u64(163);
+    let __v_23: G = G::from_u64(215);
+    let __v_24: G = G::from_u64(71);
+    let __v_25: G = G::from_u64(122);
+    let __v_26: G = G::from_u64(214);
+    let __v_27: G = G::from_u64(92);
+    let __v_28: G = G::from_u64(172);
+    let __v_29: G = G::from_u64(16);
+    let __v_30: G = G::from_u64(33);
+    let __v_31: G = G::from_u64(16);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_383] = [__v_32];
-    record.function_queries[383].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_388] = [__v_32];
+    record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_384: usize = 0;
-const IN_384: usize = 0;
-const OUT_384: usize = 1;
-fn aiur_fn_384(
-  inp: [G; IN_384],
+const INPUT_SIZE_389: usize = 0;
+const IN_389: usize = 0;
+const OUT_389: usize = 1;
+fn aiur_fn_389(
+  inp: [G; IN_389],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_384], ExecError> {
+) -> Result<[G; OUT_389], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(2);
-    let __v_1: G = G::from_u64(243);
-    let __v_2: G = G::from_u64(88);
-    let __v_3: G = G::from_u64(128);
-    let __v_4: G = G::from_u64(143);
-    let __v_5: G = G::from_u64(212);
-    let __v_6: G = G::from_u64(50);
-    let __v_7: G = G::from_u64(141);
-    let __v_8: G = G::from_u64(116);
-    let __v_9: G = G::from_u64(133);
-    let __v_10: G = G::from_u64(5);
-    let __v_11: G = G::from_u64(130);
-    let __v_12: G = G::from_u64(211);
-    let __v_13: G = G::from_u64(96);
-    let __v_14: G = G::from_u64(141);
-    let __v_15: G = G::from_u64(45);
-    let __v_16: G = G::from_u64(49);
-    let __v_17: G = G::from_u64(228);
-    let __v_18: G = G::from_u64(149);
-    let __v_19: G = G::from_u64(25);
-    let __v_20: G = G::from_u64(180);
-    let __v_21: G = G::from_u64(198);
-    let __v_22: G = G::from_u64(198);
-    let __v_23: G = G::from_u64(107);
-    let __v_24: G = G::from_u64(54);
-    let __v_25: G = G::from_u64(5);
-    let __v_26: G = G::from_u64(251);
-    let __v_27: G = G::from_u64(230);
-    let __v_28: G = G::from_u64(244);
-    let __v_29: G = G::from_u64(45);
-    let __v_30: G = G::from_u64(60);
-    let __v_31: G = G::from_u64(93);
+    let __v_0: G = G::from_u64(23);
+    let __v_1: G = G::from_u64(69);
+    let __v_2: G = G::from_u64(73);
+    let __v_3: G = G::from_u64(28);
+    let __v_4: G = G::from_u64(13);
+    let __v_5: G = G::from_u64(101);
+    let __v_6: G = G::from_u64(29);
+    let __v_7: G = G::from_u64(224);
+    let __v_8: G = G::from_u64(190);
+    let __v_9: G = G::from_u64(165);
+    let __v_10: G = G::from_u64(137);
+    let __v_11: G = G::from_u64(213);
+    let __v_12: G = G::from_u64(255);
+    let __v_13: G = G::from_u64(251);
+    let __v_14: G = G::from_u64(201);
+    let __v_15: G = G::from_u64(188);
+    let __v_16: G = G::from_u64(77);
+    let __v_17: G = G::from_u64(127);
+    let __v_18: G = G::from_u64(190);
+    let __v_19: G = G::from_u64(137);
+    let __v_20: G = G::from_u64(124);
+    let __v_21: G = G::from_u64(29);
+    let __v_22: G = G::from_u64(128);
+    let __v_23: G = G::from_u64(91);
+    let __v_24: G = G::from_u64(31);
+    let __v_25: G = G::from_u64(127);
+    let __v_26: G = G::from_u64(89);
+    let __v_27: G = G::from_u64(202);
+    let __v_28: G = G::from_u64(150);
+    let __v_29: G = G::from_u64(150);
+    let __v_30: G = G::from_u64(166);
+    let __v_31: G = G::from_u64(239);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_384] = [__v_32];
-    record.function_queries[384].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_389] = [__v_32];
+    record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_385: usize = 4;
-const IN_385: usize = 4;
-const OUT_385: usize = 2;
-fn aiur_fn_385(
-  inp: [G; IN_385],
+const INPUT_SIZE_390: usize = 4;
+const IN_390: usize = 4;
+const OUT_390: usize = 2;
+fn aiur_fn_390(
+  inp: [G; IN_390],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_385], ExecError> {
+) -> Result<[G; OUT_390], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = []; let __cu = unconstrained; let __hit = record.function_queries[379].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[379].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[379].bump_multiplicity(__i); } let __ret: [G; OUT_379] = unsafe { *(record.function_queries[379].output_at(__i).as_ptr() as *const [G; OUT_379]) }; __ret }, _ => aiur_fn_379(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -34344,8 +34532,8 @@ fn aiur_fn_385(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_385] = [__v_6, __v_10];
-        record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_390] = [__v_6, __v_10];
+        record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -34358,7 +34546,7 @@ fn aiur_fn_385(
             let __v_9: G = __loaded[3];
             match __v_6.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = []; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = []; let __cu = unconstrained; let __hit = record.function_queries[385].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => aiur_fn_385(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
@@ -34369,12 +34557,12 @@ fn aiur_fn_385(
                     let __v_14: G = G::from_u64(0);
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_385] = [__v_12, __v_16];
-                    record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_390] = [__v_12, __v_16];
+                    record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -34385,25 +34573,25 @@ fn aiur_fn_385(
                         let __v_17: G = G::from_u64(0);
                         let __v_18: G = G::from_u64(0);
                         let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_385] = [__v_15, __v_19];
-                        record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_390] = [__v_15, __v_19];
+                        record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                         let __v_16: G = __r_arr[0];
                         let __v_17: G = G::from_u64(1);
-                        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_3, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
                         let __v_25: G = __loaded[0];
@@ -34437,7 +34625,7 @@ fn aiur_fn_385(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                                     let __v_47: G = G::from_u64(2);
-                                    let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = []; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__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);
@@ -34466,13 +34654,13 @@ fn aiur_fn_385(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_786] = { let __args: [G; IN_786] = [__v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_74, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_74, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                                     let __v_78: G = __r_arr[0];
-                                    let __ret: [G; OUT_385] = [__v_77, __v_78];
-                                    record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_390] = [__v_77, __v_78];
+                                    record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -34481,8 +34669,8 @@ fn aiur_fn_385(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_385] = [__v_42, __v_46];
-                                    record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_390] = [__v_42, __v_46];
+                                    record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                 }
@@ -34493,8 +34681,8 @@ fn aiur_fn_385(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_385] = [__v_33, __v_37];
-                                record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_390] = [__v_33, __v_37];
+                                record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -34505,8 +34693,8 @@ fn aiur_fn_385(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_385] = [__v_29, __v_33];
-                            record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_390] = [__v_29, __v_33];
+                            record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -34521,8 +34709,8 @@ fn aiur_fn_385(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_385] = [__v_10, __v_14];
-                record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_390] = [__v_10, __v_14];
+                record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -34533,8 +34721,8 @@ fn aiur_fn_385(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_385] = [__v_6, __v_10];
-            record.function_queries[385].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_390] = [__v_6, __v_10];
+            record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -34543,15 +34731,15 @@ fn aiur_fn_385(
   })
 }
 
-const INPUT_SIZE_386: usize = 1;
-const IN_386: usize = 1;
-const OUT_386: usize = 1;
-fn aiur_fn_386(
-  inp: [G; IN_386],
+const INPUT_SIZE_391: usize = 1;
+const IN_391: usize = 1;
+const OUT_391: usize = 1;
+fn aiur_fn_391(
+  inp: [G; IN_391],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_386], ExecError> {
+) -> Result<[G; OUT_391], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -34561,10 +34749,10 @@ fn aiur_fn_386(
     let __v_4: G = __loaded[3];
     match __v_1.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_386] = [__v_5];
-        record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_391] = [__v_5];
+        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -34579,23 +34767,23 @@ fn aiur_fn_386(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_386] = [__v_15];
-        record.function_queries[386].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_391] = [__v_15];
+        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_387: usize = 2;
-const IN_387: usize = 2;
-const OUT_387: usize = 1;
-fn aiur_fn_387(
-  inp: [G; IN_387],
+const INPUT_SIZE_392: usize = 2;
+const IN_392: usize = 2;
+const OUT_392: usize = 1;
+fn aiur_fn_392(
+  inp: [G; IN_392],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_387], ExecError> {
+) -> Result<[G; OUT_392], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -34608,19 +34796,19 @@ fn aiur_fn_387(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_387] = [__v_7];
-        record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_392] = [__v_7];
+        record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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_387] = { let __args: [G; IN_387] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_387] = [__v_8];
-        record.function_queries[387].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_392] = [__v_8];
+        record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -34630,28 +34818,28 @@ fn aiur_fn_387(
   })
 }
 
-const INPUT_SIZE_388: usize = 3;
-const IN_388: usize = 3;
-const OUT_388: usize = 2;
-fn aiur_fn_388(
-  inp: [G; IN_388],
+const INPUT_SIZE_393: usize = 3;
+const IN_393: usize = 3;
+const OUT_393: usize = 2;
+fn aiur_fn_393(
+  inp: [G; IN_393],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_388], ExecError> {
+) -> Result<[G; OUT_393], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
@@ -34666,31 +34854,31 @@ fn aiur_fn_388(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_388] = [__v_11, __v_15];
-            record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_393] = [__v_11, __v_15];
+            record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
             match __v_13.as_canonical_u64() {
               1u64 => {
                 let __v_15: G = G::from_u64(1);
-                let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_116] = { let __args: [G; IN_116] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_19, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_19, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
-                let __ret: [G; OUT_388] = [__v_17, __v_20];
-                record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_393] = [__v_17, __v_20];
+                record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -34699,8 +34887,8 @@ fn aiur_fn_388(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_388] = [__v_15, __v_19];
-                record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_393] = [__v_15, __v_19];
+                record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -34719,33 +34907,33 @@ fn aiur_fn_388(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_388] = [__v_11, __v_15];
-                record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_393] = [__v_11, __v_15];
+                record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
                     let __v_15: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_125] = { let __args: [G; IN_125] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
-                    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                     let __v_19: G = __r_arr[0];
-                    let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
                     let __v_20: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_20, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_21: G = __r_arr[0];
-                    let __ret: [G; OUT_388] = [__v_17, __v_21];
-                    record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_393] = [__v_17, __v_21];
+                    record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -34754,8 +34942,8 @@ fn aiur_fn_388(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_388] = [__v_15, __v_19];
-                    record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_393] = [__v_15, __v_19];
+                    record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -34763,11 +34951,11 @@ fn aiur_fn_388(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[269].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[269].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[269].bump_multiplicity(__i); } let __ret: [G; OUT_269] = unsafe { *(record.function_queries[269].output_at(__i).as_ptr() as *const [G; OUT_269]) }; __ret }, _ => aiur_fn_269(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_388] = [__v_9, __v_10];
-            record.function_queries[388].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_393] = [__v_9, __v_10];
+            record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -34776,19 +34964,19 @@ fn aiur_fn_388(
   })
 }
 
-const INPUT_SIZE_389: usize = 2;
-const IN_389: usize = 2;
-const OUT_389: usize = 1;
-fn aiur_fn_389(
-  inp: [G; IN_389],
+const INPUT_SIZE_394: usize = 2;
+const IN_394: usize = 2;
+const OUT_394: usize = 1;
+fn aiur_fn_394(
+  inp: [G; IN_394],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_389], ExecError> {
+) -> Result<[G; OUT_394], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -34796,8 +34984,8 @@ fn aiur_fn_389(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_389] = [__v_2];
-        record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_394] = [__v_2];
+        record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -34807,26 +34995,26 @@ fn aiur_fn_389(
         let __v_8: G = __loaded[2];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_389] = [__v_2];
-            record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_394] = [__v_2];
+            record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_389] = [__v_17];
-            record.function_queries[389].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_394] = [__v_17];
+            record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -34841,18 +35029,18 @@ fn aiur_fn_389(
   })
 }
 
-const INPUT_SIZE_390: usize = 1;
-const IN_390: usize = 1;
-const OUT_390: usize = 1;
-fn aiur_fn_390(
-  inp: [G; IN_390],
+const INPUT_SIZE_395: usize = 1;
+const IN_395: usize = 1;
+const OUT_395: usize = 1;
+fn aiur_fn_395(
+  inp: [G; IN_395],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_390], ExecError> {
+) -> Result<[G; OUT_395], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
@@ -34862,7 +35050,7 @@ fn aiur_fn_390(
     break '__mc_0 [__v_3];
   },
   _ => {
-    let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = []; let __cu = unconstrained; let __hit = record.function_queries[149].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[149].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[149].bump_multiplicity(__i); } let __ret: [G; OUT_149] = unsafe { *(record.function_queries[149].output_at(__i).as_ptr() as *const [G; OUT_149]) }; __ret }, _ => aiur_fn_149(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = []; let __cu = unconstrained; let __hit = record.function_queries[154].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[154].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[154].bump_multiplicity(__i); } let __ret: [G; OUT_154] = unsafe { *(record.function_queries[154].output_at(__i).as_ptr() as *const [G; OUT_154]) }; __ret }, _ => aiur_fn_154(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
@@ -34872,7 +35060,7 @@ fn aiur_fn_390(
         break '__mc_0 [__v_5];
       },
       _ => {
-        let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
@@ -34882,7 +35070,7 @@ fn aiur_fn_390(
             break '__mc_0 [__v_7];
           },
           _ => {
-            let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = []; let __cu = unconstrained; let __hit = record.function_queries[163].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[163].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[163].bump_multiplicity(__i); } let __ret: [G; OUT_163] = unsafe { *(record.function_queries[163].output_at(__i).as_ptr() as *const [G; OUT_163]) }; __ret }, _ => aiur_fn_163(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
@@ -34892,7 +35080,7 @@ fn aiur_fn_390(
                 break '__mc_0 [__v_9];
               },
               _ => {
-                let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = []; let __cu = unconstrained; let __hit = record.function_queries[164].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[164].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[164].bump_multiplicity(__i); } let __ret: [G; OUT_164] = unsafe { *(record.function_queries[164].output_at(__i).as_ptr() as *const [G; OUT_164]) }; __ret }, _ => aiur_fn_164(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
@@ -34902,7 +35090,7 @@ fn aiur_fn_390(
                     break '__mc_0 [__v_11];
                   },
                   _ => {
-                    let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = []; let __cu = unconstrained; let __hit = record.function_queries[168].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[168].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[168].bump_multiplicity(__i); } let __ret: [G; OUT_168] = unsafe { *(record.function_queries[168].output_at(__i).as_ptr() as *const [G; OUT_168]) }; __ret }, _ => aiur_fn_168(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
                     let __v_11: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
@@ -34912,7 +35100,7 @@ fn aiur_fn_390(
                         break '__mc_0 [__v_13];
                       },
                       _ => {
-                        let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
                         let __v_13: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_14: G = __r_arr[0];
@@ -34922,7 +35110,7 @@ fn aiur_fn_390(
                             break '__mc_0 [__v_15];
                           },
                           _ => {
-                            let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = []; let __cu = unconstrained; let __hit = record.function_queries[165].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[165].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[165].bump_multiplicity(__i); } let __ret: [G; OUT_165] = unsafe { *(record.function_queries[165].output_at(__i).as_ptr() as *const [G; OUT_165]) }; __ret }, _ => aiur_fn_165(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } };
                             let __v_15: G = __r_arr[0];
                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                             let __v_16: G = __r_arr[0];
@@ -34932,7 +35120,7 @@ fn aiur_fn_390(
                                 break '__mc_0 [__v_17];
                               },
                               _ => {
-                                let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = []; let __cu = unconstrained; let __hit = record.function_queries[166].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[166].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[166].bump_multiplicity(__i); } let __ret: [G; OUT_166] = unsafe { *(record.function_queries[166].output_at(__i).as_ptr() as *const [G; OUT_166]) }; __ret }, _ => aiur_fn_166(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } };
                                 let __v_17: G = __r_arr[0];
                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                 let __v_18: G = __r_arr[0];
@@ -34942,7 +35130,7 @@ fn aiur_fn_390(
                                     break '__mc_0 [__v_19];
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = []; let __cu = unconstrained; let __hit = record.function_queries[179].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[179].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[179].bump_multiplicity(__i); } let __ret: [G; OUT_179] = unsafe { *(record.function_queries[179].output_at(__i).as_ptr() as *const [G; OUT_179]) }; __ret }, _ => aiur_fn_179(__args, record, io_buffer, __cu)? } };
                                     let __v_19: G = __r_arr[0];
                                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                     let __v_20: G = __r_arr[0];
@@ -34952,7 +35140,7 @@ fn aiur_fn_390(
                                         break '__mc_0 [__v_21];
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = []; let __cu = unconstrained; let __hit = record.function_queries[180].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[180].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[180].bump_multiplicity(__i); } let __ret: [G; OUT_180] = unsafe { *(record.function_queries[180].output_at(__i).as_ptr() as *const [G; OUT_180]) }; __ret }, _ => aiur_fn_180(__args, record, io_buffer, __cu)? } };
                                         let __v_21: G = __r_arr[0];
                                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                         let __v_22: G = __r_arr[0];
@@ -34962,7 +35150,7 @@ fn aiur_fn_390(
                                             break '__mc_0 [__v_23];
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = []; let __cu = unconstrained; let __hit = record.function_queries[169].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[169].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[169].bump_multiplicity(__i); } let __ret: [G; OUT_169] = unsafe { *(record.function_queries[169].output_at(__i).as_ptr() as *const [G; OUT_169]) }; __ret }, _ => aiur_fn_169(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_174] = { let __args: [G; IN_174] = []; let __cu = unconstrained; let __hit = record.function_queries[174].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[174].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[174].bump_multiplicity(__i); } let __ret: [G; OUT_174] = unsafe { *(record.function_queries[174].output_at(__i).as_ptr() as *const [G; OUT_174]) }; __ret }, _ => aiur_fn_174(__args, record, io_buffer, __cu)? } };
                                             let __v_23: G = __r_arr[0];
                                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                             let __v_24: G = __r_arr[0];
@@ -34972,7 +35160,7 @@ fn aiur_fn_390(
                                                 break '__mc_0 [__v_25];
                                               },
                                               _ => {
-                                                let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = []; let __cu = unconstrained; let __hit = record.function_queries[170].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[170].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[170].bump_multiplicity(__i); } let __ret: [G; OUT_170] = unsafe { *(record.function_queries[170].output_at(__i).as_ptr() as *const [G; OUT_170]) }; __ret }, _ => aiur_fn_170(__args, record, io_buffer, __cu)? } };
+                                                let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = []; let __cu = unconstrained; let __hit = record.function_queries[175].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[175].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[175].bump_multiplicity(__i); } let __ret: [G; OUT_175] = unsafe { *(record.function_queries[175].output_at(__i).as_ptr() as *const [G; OUT_175]) }; __ret }, _ => aiur_fn_175(__args, record, io_buffer, __cu)? } };
                                                 let __v_25: G = __r_arr[0];
                                                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                 let __v_26: G = __r_arr[0];
@@ -34982,7 +35170,7 @@ fn aiur_fn_390(
                                                     break '__mc_0 [__v_27];
                                                   },
                                                   _ => {
-                                                    let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = []; let __cu = unconstrained; let __hit = record.function_queries[171].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[171].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[171].bump_multiplicity(__i); } let __ret: [G; OUT_171] = unsafe { *(record.function_queries[171].output_at(__i).as_ptr() as *const [G; OUT_171]) }; __ret }, _ => aiur_fn_171(__args, record, io_buffer, __cu)? } };
+                                                    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } };
                                                     let __v_27: G = __r_arr[0];
                                                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                     let __v_28: G = __r_arr[0];
@@ -34992,7 +35180,7 @@ fn aiur_fn_390(
                                                         break '__mc_0 [__v_29];
                                                       },
                                                       _ => {
-                                                        let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = []; let __cu = unconstrained; let __hit = record.function_queries[172].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[172].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[172].bump_multiplicity(__i); } let __ret: [G; OUT_172] = unsafe { *(record.function_queries[172].output_at(__i).as_ptr() as *const [G; OUT_172]) }; __ret }, _ => aiur_fn_172(__args, record, io_buffer, __cu)? } };
+                                                        let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } };
                                                         let __v_29: G = __r_arr[0];
                                                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                         let __v_30: G = __r_arr[0];
@@ -35002,7 +35190,7 @@ fn aiur_fn_390(
                                                             break '__mc_0 [__v_31];
                                                           },
                                                           _ => {
-                                                            let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = []; let __cu = unconstrained; let __hit = record.function_queries[173].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[173].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[173].bump_multiplicity(__i); } let __ret: [G; OUT_173] = unsafe { *(record.function_queries[173].output_at(__i).as_ptr() as *const [G; OUT_173]) }; __ret }, _ => aiur_fn_173(__args, record, io_buffer, __cu)? } };
+                                                            let __r_arr: [G; OUT_178] = { let __args: [G; IN_178] = []; let __cu = unconstrained; let __hit = record.function_queries[178].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[178].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[178].bump_multiplicity(__i); } let __ret: [G; OUT_178] = unsafe { *(record.function_queries[178].output_at(__i).as_ptr() as *const [G; OUT_178]) }; __ret }, _ => aiur_fn_178(__args, record, io_buffer, __cu)? } };
                                                             let __v_31: G = __r_arr[0];
                                                             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                                                             let __v_32: G = __r_arr[0];
@@ -35051,64 +35239,64 @@ fn aiur_fn_390(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_390] = [__v_4];
-        record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_395] = [__v_4];
+        record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[219].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[219].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[219].bump_multiplicity(__i); } let __ret: [G; OUT_219] = unsafe { *(record.function_queries[219].output_at(__i).as_ptr() as *const [G; OUT_219]) }; __ret }, _ => aiur_fn_219(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[224].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[224].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[224].bump_multiplicity(__i); } let __ret: [G; OUT_224] = unsafe { *(record.function_queries[224].output_at(__i).as_ptr() as *const [G; OUT_224]) }; __ret }, _ => aiur_fn_224(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(2);
-            let __ret: [G; OUT_390] = [__v_5];
-            record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_395] = [__v_5];
+            record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[197].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[197].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[197].bump_multiplicity(__i); } let __ret: [G; OUT_197] = unsafe { *(record.function_queries[197].output_at(__i).as_ptr() as *const [G; OUT_197]) }; __ret }, _ => aiur_fn_197(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[202].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[202].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[202].bump_multiplicity(__i); } let __ret: [G; OUT_202] = unsafe { *(record.function_queries[202].output_at(__i).as_ptr() as *const [G; OUT_202]) }; __ret }, _ => aiur_fn_202(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             match __v_5.as_canonical_u64() {
               1u64 => {
                 let __v_6: G = G::from_u64(3);
-                let __ret: [G; OUT_390] = [__v_6];
-                record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_395] = [__v_6];
+                record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[184].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[184].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[184].bump_multiplicity(__i); } let __ret: [G; OUT_184] = unsafe { *(record.function_queries[184].output_at(__i).as_ptr() as *const [G; OUT_184]) }; __ret }, _ => aiur_fn_184(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[189].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[189].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[189].bump_multiplicity(__i); } let __ret: [G; OUT_189] = unsafe { *(record.function_queries[189].output_at(__i).as_ptr() as *const [G; OUT_189]) }; __ret }, _ => aiur_fn_189(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
                 match __v_6.as_canonical_u64() {
                   1u64 => {
                     let __v_7: G = G::from_u64(4);
-                    let __ret: [G; OUT_390] = [__v_7];
-                    record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_395] = [__v_7];
+                    record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[525].bump_multiplicity(__i); } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } };
                     let __v_7: G = __r_arr[0];
                     match __v_7.as_canonical_u64() {
                       1u64 => {
                         let __v_8: G = G::from_u64(5);
-                        let __ret: [G; OUT_390] = [__v_8];
-                        record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_395] = [__v_8];
+                        record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[242].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[242].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[242].bump_multiplicity(__i); } let __ret: [G; OUT_242] = unsafe { *(record.function_queries[242].output_at(__i).as_ptr() as *const [G; OUT_242]) }; __ret }, _ => aiur_fn_242(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[247].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[247].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[247].bump_multiplicity(__i); } let __ret: [G; OUT_247] = unsafe { *(record.function_queries[247].output_at(__i).as_ptr() as *const [G; OUT_247]) }; __ret }, _ => aiur_fn_247(__args, record, io_buffer, __cu)? } };
                         let __v_8: G = __r_arr[0];
                         match __v_8.as_canonical_u64() {
                           1u64 => {
                             let __v_9: G = G::from_u64(6);
-                            let __ret: [G; OUT_390] = [__v_9];
-                            record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_395] = [__v_9];
+                            record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_9: G = G::from_u64(0);
-                            let __ret: [G; OUT_390] = [__v_9];
-                            record.function_queries[390].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_395] = [__v_9];
+                            record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -35125,71 +35313,71 @@ fn aiur_fn_390(
   })
 }
 
-const INPUT_SIZE_391: usize = 4;
-const IN_391: usize = 4;
-const OUT_391: usize = 2;
-fn aiur_fn_391(
-  inp: [G; IN_391],
+const INPUT_SIZE_396: usize = 4;
+const IN_396: usize = 4;
+const OUT_396: usize = 2;
+fn aiur_fn_396(
+  inp: [G; IN_396],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_391], ExecError> {
+) -> Result<[G; OUT_396], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[393].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i); } let __ret: [G; OUT_393] = unsafe { *(record.function_queries[393].output_at(__i).as_ptr() as *const [G; OUT_393]) }; __ret }, _ => aiur_fn_393(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_391] = [__v_5, __v_6];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_5, __v_6];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[220].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[220].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[220].bump_multiplicity(__i); } let __ret: [G; OUT_220] = unsafe { *(record.function_queries[220].output_at(__i).as_ptr() as *const [G; OUT_220]) }; __ret }, _ => aiur_fn_220(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[225].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[225].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[225].bump_multiplicity(__i); } let __ret: [G; OUT_225] = unsafe { *(record.function_queries[225].output_at(__i).as_ptr() as *const [G; OUT_225]) }; __ret }, _ => aiur_fn_225(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __ret: [G; OUT_391] = [__v_6, __v_7];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_6, __v_7];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[203].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[203].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[203].bump_multiplicity(__i); } let __ret: [G; OUT_203] = unsafe { *(record.function_queries[203].output_at(__i).as_ptr() as *const [G; OUT_203]) }; __ret }, _ => aiur_fn_203(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[208].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[208].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[208].bump_multiplicity(__i); } let __ret: [G; OUT_208] = unsafe { *(record.function_queries[208].output_at(__i).as_ptr() as *const [G; OUT_208]) }; __ret }, _ => aiur_fn_208(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_391] = [__v_5, __v_6];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_5, __v_6];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[187].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[187].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[187].bump_multiplicity(__i); } let __ret: [G; OUT_187] = unsafe { *(record.function_queries[187].output_at(__i).as_ptr() as *const [G; OUT_187]) }; __ret }, _ => aiur_fn_187(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[192].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[192].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[192].bump_multiplicity(__i); } let __ret: [G; OUT_192] = unsafe { *(record.function_queries[192].output_at(__i).as_ptr() as *const [G; OUT_192]) }; __ret }, _ => aiur_fn_192(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_391] = [__v_5, __v_6];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_5, __v_6];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_391] = [__v_5, __v_6];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_5, __v_6];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[253].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[253].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[253].bump_multiplicity(__i); } let __ret: [G; OUT_253] = unsafe { *(record.function_queries[253].output_at(__i).as_ptr() as *const [G; OUT_253]) }; __ret }, _ => aiur_fn_253(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[258].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[258].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[258].bump_multiplicity(__i); } let __ret: [G; OUT_258] = unsafe { *(record.function_queries[258].output_at(__i).as_ptr() as *const [G; OUT_258]) }; __ret }, _ => aiur_fn_258(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_391] = [__v_5, __v_6];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_5, __v_6];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -35198,52 +35386,52 @@ fn aiur_fn_391(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_391] = [__v_5, __v_9];
-        record.function_queries[391].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_396] = [__v_5, __v_9];
+        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_392: usize = 3;
-const IN_392: usize = 3;
-const OUT_392: usize = 2;
-fn aiur_fn_392(
-  inp: [G; IN_392],
+const INPUT_SIZE_397: usize = 3;
+const IN_397: usize = 3;
+const OUT_397: usize = 2;
+fn aiur_fn_397(
+  inp: [G; IN_397],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_392], ExecError> {
+) -> Result<[G; OUT_397], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = []; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[393].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[393].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[393].bump_multiplicity(__i); } let __ret: [G; OUT_393] = unsafe { *(record.function_queries[393].output_at(__i).as_ptr() as *const [G; OUT_393]) }; __ret }, _ => aiur_fn_393(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[398].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => aiur_fn_398(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = __r_arr[1];
-        let __ret: [G; OUT_392] = [__v_5, __v_6];
-        record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_397] = [__v_5, __v_6];
+        record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __cu = unconstrained; let __hit = record.function_queries[389].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { *(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389]) }; __ret }, _ => aiur_fn_389(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[394].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[394].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[394].bump_multiplicity(__i); } let __ret: [G; OUT_394] = unsafe { *(record.function_queries[394].output_at(__i).as_ptr() as *const [G; OUT_394]) }; __ret }, _ => aiur_fn_394(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[399].bump_multiplicity(__i); } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = __r_arr[1];
-            let __ret: [G; OUT_392] = [__v_7, __v_8];
-            record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_397] = [__v_7, __v_8];
+            record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -35252,8 +35440,8 @@ fn aiur_fn_392(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_392] = [__v_7, __v_11];
-            record.function_queries[392].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_397] = [__v_7, __v_11];
+            record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35262,19 +35450,19 @@ fn aiur_fn_392(
   })
 }
 
-const INPUT_SIZE_393: usize = 2;
-const IN_393: usize = 2;
-const OUT_393: usize = 2;
-fn aiur_fn_393(
-  inp: [G; IN_393],
+const INPUT_SIZE_398: usize = 2;
+const IN_398: usize = 2;
+const OUT_398: usize = 2;
+fn aiur_fn_398(
+  inp: [G; IN_398],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_393], ExecError> {
+) -> Result<[G; OUT_398], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -35285,33 +35473,33 @@ fn aiur_fn_393(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_393] = [__v_5, __v_9];
-        record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_398] = [__v_5, __v_9];
+        record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(3);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(6);
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_393] = [__v_13, __v_17];
-            record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_398] = [__v_13, __v_17];
+            record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -35320,8 +35508,8 @@ fn aiur_fn_393(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_393] = [__v_11, __v_15];
-            record.function_queries[393].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_398] = [__v_11, __v_15];
+            record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35330,19 +35518,19 @@ fn aiur_fn_393(
   })
 }
 
-const INPUT_SIZE_394: usize = 2;
-const IN_394: usize = 2;
-const OUT_394: usize = 2;
-fn aiur_fn_394(
-  inp: [G; IN_394],
+const INPUT_SIZE_399: usize = 2;
+const IN_399: usize = 2;
+const OUT_399: usize = 2;
+fn aiur_fn_399(
+  inp: [G; IN_399],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_394], ExecError> {
+) -> Result<[G; OUT_399], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -35353,33 +35541,33 @@ fn aiur_fn_394(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_394] = [__v_5, __v_9];
-        record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_399] = [__v_5, __v_9];
+        record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(3);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         match __v_9.as_canonical_u64() {
           1u64 => {
             let __v_11: G = G::from_u64(5);
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_16, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_394] = [__v_13, __v_17];
-            record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_399] = [__v_13, __v_17];
+            record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -35388,8 +35576,8 @@ fn aiur_fn_394(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_394] = [__v_11, __v_15];
-            record.function_queries[394].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_399] = [__v_11, __v_15];
+            record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35398,21 +35586,21 @@ fn aiur_fn_394(
   })
 }
 
-const INPUT_SIZE_395: usize = 2;
-const IN_395: usize = 2;
-const OUT_395: usize = 2;
-fn aiur_fn_395(
-  inp: [G; IN_395],
+const INPUT_SIZE_400: usize = 2;
+const IN_400: usize = 2;
+const OUT_400: usize = 2;
+fn aiur_fn_400(
+  inp: [G; IN_400],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_395], ExecError> {
+) -> Result<[G; OUT_400], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -35422,13 +35610,13 @@ fn aiur_fn_395(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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);
@@ -35436,10 +35624,10 @@ fn aiur_fn_395(
               0u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = G::from_u64(2);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
-                let __ret: [G; OUT_395] = [__v_14, __v_16];
-                record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_400] = [__v_14, __v_16];
+                record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -35448,8 +35636,8 @@ fn aiur_fn_395(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_395] = [__v_14, __v_18];
-                record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_400] = [__v_14, __v_18];
+                record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -35460,8 +35648,8 @@ fn aiur_fn_395(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_395] = [__v_11, __v_15];
-            record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_400] = [__v_11, __v_15];
+            record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35472,47 +35660,47 @@ fn aiur_fn_395(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_395] = [__v_9, __v_13];
-        record.function_queries[395].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_400] = [__v_9, __v_13];
+        record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_396: usize = 5;
-const IN_396: usize = 5;
-const OUT_396: usize = 1;
-fn aiur_fn_396(
-  inp: [G; IN_396],
+const INPUT_SIZE_401: usize = 5;
+const IN_401: usize = 5;
+const OUT_401: usize = 1;
+fn aiur_fn_401(
+  inp: [G; IN_401],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_396], ExecError> {
+) -> Result<[G; OUT_401], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i); } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_396] = [__v_7];
-        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_401] = [__v_7];
+        record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_396] = [__v_6];
-        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_401] = [__v_6];
+        record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -35529,52 +35717,52 @@ fn aiur_fn_396(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
             match __v_20.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_396] = [__v_22];
-                record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_401] = [__v_22];
+                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_22, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_396] = [__v_23];
-                record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_401] = [__v_23];
+                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           2u64 => {
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_396] = [__v_20];
-            record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_401] = [__v_20];
+            record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = __r_arr[1];
             match __v_20.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_396] = [__v_22];
-                record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_401] = [__v_22];
+                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_396] = [__v_22];
-                record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_401] = [__v_22];
+                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -35585,10 +35773,10 @@ fn aiur_fn_396(
             let __v_22: G = (__v_21 + __v_12);
             let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_16.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
     let __v_24: G = __r_arr[1];
-    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[405].bump_multiplicity(__i); } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
     let __v_26: G = __r_arr[1];
     break '__mc_0 [__v_25, __v_26];
@@ -35603,46 +35791,46 @@ fn aiur_fn_396(
             let __v_24: G = __mc_out___mc_0[1];
             match __v_23.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_396] = [__v_24];
-                record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_401] = [__v_24];
+                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_10, __v_11, __v_13, __v_14, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
                 let __v_25: G = __r_arr[0];
-                let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4, __v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } };
                 let __v_26: G = __r_arr[0];
                 let __v_27: G = __r_arr[1];
                 match __v_26.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_27, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_27, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
                     let __v_28: G = __r_arr[0];
-                    let __ret: [G; OUT_396] = [__v_28];
-                    record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_401] = [__v_28];
+                    record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   2u64 => {
                     match __v_16.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_396] = [__v_27];
-                        record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_401] = [__v_27];
+                        record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_10, __v_1, __v_3, __v_11, __v_13, __v_14, __v_12, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } };
                         let __v_28: G = __r_arr[0];
                         let __v_29: G = __r_arr[1];
                         match __v_28.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_29, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
                             let __v_30: G = __r_arr[0];
-                            let __ret: [G; OUT_396] = [__v_30];
-                            record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_401] = [__v_30];
+                            record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __ret: [G; OUT_396] = [__v_27];
-                            record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_401] = [__v_27];
+                            record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -35650,10 +35838,10 @@ fn aiur_fn_396(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_28: G = __r_arr[0];
-                    let __ret: [G; OUT_396] = [__v_28];
-                    record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_401] = [__v_28];
+                    record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -35661,10 +35849,10 @@ fn aiur_fn_396(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __ret: [G; OUT_396] = [__v_20];
-            record.function_queries[396].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_401] = [__v_20];
+            record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35673,20 +35861,20 @@ fn aiur_fn_396(
   })
 }
 
-const INPUT_SIZE_397: usize = 2;
-const IN_397: usize = 2;
-const OUT_397: usize = 2;
-fn aiur_fn_397(
-  inp: [G; IN_397],
+const INPUT_SIZE_402: usize = 2;
+const IN_402: usize = 2;
+const OUT_402: usize = 2;
+fn aiur_fn_402(
+  inp: [G; IN_402],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_397], ExecError> {
+) -> Result<[G; OUT_402], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(0);
-    let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[398].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => aiur_fn_398(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__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];
@@ -35694,7 +35882,7 @@ fn aiur_fn_397(
     let __v_7: G = __r_arr[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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() {
@@ -35704,22 +35892,22 @@ fn aiur_fn_397(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_397] = [__v_10, __v_14];
-            record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_402] = [__v_10, __v_14];
+            record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_397] = [__v_14, __v_15];
-            record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_402] = [__v_14, __v_15];
+            record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35730,23 +35918,23 @@ fn aiur_fn_397(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_397] = [__v_8, __v_12];
-        record.function_queries[397].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_402] = [__v_8, __v_12];
+        record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_398: usize = 2;
-const IN_398: usize = 2;
-const OUT_398: usize = 5;
-fn aiur_fn_398(
-  inp: [G; IN_398],
+const INPUT_SIZE_403: usize = 2;
+const IN_403: usize = 2;
+const OUT_403: usize = 5;
+fn aiur_fn_403(
+  inp: [G; IN_403],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_398], ExecError> {
+) -> Result<[G; OUT_403], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -35759,14 +35947,14 @@ fn aiur_fn_398(
       4u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[398].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[398].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[398].bump_multiplicity(__i); } let __ret: [G; OUT_398] = unsafe { *(record.function_queries[398].output_at(__i).as_ptr() as *const [G; OUT_398]) }; __ret }, _ => aiur_fn_398(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = __r_arr[2];
         let __v_11: G = __r_arr[3];
         let __v_12: G = __r_arr[4];
-        let __ret: [G; OUT_398] = [__v_8, __v_9, __v_10, __v_11, __v_12];
-        record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_403] = [__v_8, __v_9, __v_10, __v_11, __v_12];
+        record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
@@ -35784,8 +35972,8 @@ fn aiur_fn_398(
                 let __v_12: G = G::from_u64(1);
                 let __v_13: G = (__v_1 - __v_12);
                 let __v_14: G = (__v_13 - __v_7);
-                let __ret: [G; OUT_398] = [__v_11, __v_1, __v_3, __v_4, __v_14];
-                record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_403] = [__v_11, __v_1, __v_3, __v_4, __v_14];
+                record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -35826,8 +36014,8 @@ fn aiur_fn_398(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_46: G = G::from_u64(0);
                 let __v_47: G = G::from_u64(0);
-                let __ret: [G; OUT_398] = [__v_11, __v_12, __v_45, __v_46, __v_47];
-                record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_403] = [__v_11, __v_12, __v_45, __v_46, __v_47];
+                record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -35870,8 +36058,8 @@ fn aiur_fn_398(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_45: G = G::from_u64(0);
             let __v_46: G = G::from_u64(0);
-            let __ret: [G; OUT_398] = [__v_10, __v_11, __v_44, __v_45, __v_46];
-            record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_403] = [__v_10, __v_11, __v_44, __v_45, __v_46];
+            record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -35914,23 +36102,23 @@ fn aiur_fn_398(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(0);
-        let __ret: [G; OUT_398] = [__v_6, __v_7, __v_40, __v_41, __v_42];
-        record.function_queries[398].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_403] = [__v_6, __v_7, __v_40, __v_41, __v_42];
+        record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_399: usize = 1;
-const IN_399: usize = 1;
-const OUT_399: usize = 1;
-fn aiur_fn_399(
-  inp: [G; IN_399],
+const INPUT_SIZE_404: usize = 1;
+const IN_404: usize = 1;
+const OUT_404: usize = 1;
+fn aiur_fn_404(
+  inp: [G; IN_404],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_399], ExecError> {
+) -> Result<[G; OUT_404], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -35942,33 +36130,33 @@ fn aiur_fn_399(
       7u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             match __v_5.as_canonical_u64() {
               1u64 => {
                 let __v_6: G = G::from_u64(2);
-                let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_399] = [__v_12];
-                record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_404] = [__v_12];
+                record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[125].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[125].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[125].bump_multiplicity(__i); } let __ret: [G; OUT_125] = unsafe { *(record.function_queries[125].output_at(__i).as_ptr() as *const [G; OUT_125]) }; __ret }, _ => aiur_fn_125(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[130].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[130].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[130].bump_multiplicity(__i); } let __ret: [G; OUT_130] = unsafe { *(record.function_queries[130].output_at(__i).as_ptr() as *const [G; OUT_130]) }; __ret }, _ => aiur_fn_130(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
-                let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __v_8: G = G::from_u64(7);
                 let __v_9: G = G::from_u64(0);
                 let __v_10: G = G::from_u64(0);
                 let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
                 let __v_12: G = G::from_u64(2);
-                let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__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);
@@ -35978,37 +36166,37 @@ fn aiur_fn_399(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_399] = [__v_21];
-                record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_404] = [__v_21];
+                record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_399] = [__v_0];
-            record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_404] = [__v_0];
+            record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_399] = [__v_0];
-        record.function_queries[399].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_404] = [__v_0];
+        record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_400: usize = 9;
-const IN_400: usize = 9;
-const OUT_400: usize = 2;
-fn aiur_fn_400(
-  inp: [G; IN_400],
+const INPUT_SIZE_405: usize = 9;
+const IN_405: usize = 9;
+const OUT_405: usize = 2;
+fn aiur_fn_405(
+  inp: [G; IN_405],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_400], ExecError> {
+) -> Result<[G; OUT_405], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36032,7 +36220,7 @@ fn aiur_fn_400(
             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_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
@@ -36043,14 +36231,14 @@ fn aiur_fn_400(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_400] = [__v_19, __v_23];
-                record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_405] = [__v_19, __v_23];
+                record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
-                let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[401].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[401].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[401].bump_multiplicity(__i); } let __ret: [G; OUT_401] = unsafe { *(record.function_queries[401].output_at(__i).as_ptr() as *const [G; OUT_401]) }; __ret }, _ => aiur_fn_401(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_19, __v_10, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i); } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
                 match __v_20.as_canonical_u64() {
                   0u64 => {
@@ -36059,30 +36247,30 @@ fn aiur_fn_400(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_400] = [__v_21, __v_25];
-                    record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_405] = [__v_21, __v_25];
+                    record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_12, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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_785] = { let __args: [G; IN_785] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__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_786] = { let __args: [G; IN_786] = [__v_1, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                     let __v_27: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_28: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_28, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_28, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__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_417] = { let __args: [G; IN_417] = [__v_29, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_29, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
                     let __v_31: G = __r_arr[0];
-                    let __ret: [G; OUT_400] = [__v_30, __v_31];
-                    record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_405] = [__v_30, __v_31];
+                    record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -36097,34 +36285,34 @@ fn aiur_fn_400(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_400] = [__v_14, __v_18];
-        record.function_queries[400].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_405] = [__v_14, __v_18];
+        record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_401: usize = 5;
-const IN_401: usize = 5;
-const OUT_401: usize = 1;
-fn aiur_fn_401(
-  inp: [G; IN_401],
+const INPUT_SIZE_406: usize = 5;
+const IN_406: usize = 5;
+const OUT_406: usize = 1;
+fn aiur_fn_406(
+  inp: [G; IN_406],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_401], ExecError> {
+) -> Result<[G; OUT_406], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -36139,12 +36327,12 @@ fn aiur_fn_401(
         match __v_13.as_canonical_u64() {
           0u64 => {
             let __v_14: G = G::from_u64(0);
-            let __ret: [G; OUT_401] = [__v_14];
-            record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_406] = [__v_14];
+            record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
@@ -36161,27 +36349,27 @@ fn aiur_fn_401(
             let __v_26: G = __loaded[11];
             match __v_15.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_22, __v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } };
                 let __v_27: G = __r_arr[0];
                 let __v_28: G = G::from_u64(2);
                 let __v_29: G = G::from_u64(0);
                 let __v_30: G = { let __values: [G; 4] = [__v_28, __v_27, __v_11, __v_29]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
                 let __v_31: G = __r_arr[0];
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_32: G = __r_arr[0];
-                let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_32, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_32, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
                 let __v_33: G = __r_arr[0];
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_33, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_34: G = __r_arr[0];
-                let __ret: [G; OUT_401] = [__v_34];
-                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_406] = [__v_34];
+                record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_27: G = G::from_u64(0);
-                let __ret: [G; OUT_401] = [__v_27];
-                record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_406] = [__v_27];
+                record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -36190,63 +36378,63 @@ fn aiur_fn_401(
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_401] = [__v_13];
-        record.function_queries[401].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_406] = [__v_13];
+        record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_402: usize = 3;
-const IN_402: usize = 3;
-const OUT_402: usize = 1;
-fn aiur_fn_402(
-  inp: [G; IN_402],
+const INPUT_SIZE_407: usize = 3;
+const IN_407: usize = 3;
+const OUT_407: usize = 1;
+fn aiur_fn_407(
+  inp: [G; IN_407],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_402], ExecError> {
+) -> Result<[G; OUT_407], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__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_786] = { let __args: [G; IN_786] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_12, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __ret: [G; OUT_402] = [__v_13];
-    record.function_queries[402].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_407] = [__v_13];
+    record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_403: usize = 2;
-const IN_403: usize = 2;
-const OUT_403: usize = 1;
-fn aiur_fn_403(
-  inp: [G; IN_403],
+const INPUT_SIZE_408: usize = 2;
+const IN_408: usize = 2;
+const OUT_408: usize = 1;
+fn aiur_fn_408(
+  inp: [G; IN_408],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_403], ExecError> {
+) -> Result<[G; OUT_408], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -36256,7 +36444,7 @@ fn aiur_fn_403(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -36273,41 +36461,41 @@ fn aiur_fn_403(
         let __v_21: G = __loaded[11];
         match __v_10.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_22, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_23, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
-            let __ret: [G; OUT_403] = [__v_24];
-            record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_408] = [__v_24];
+            record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_403] = [__v_2];
-            record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_408] = [__v_2];
+            record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __ret: [G; OUT_403] = [__v_2];
-        record.function_queries[403].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_408] = [__v_2];
+        record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_404: usize = 10;
-const IN_404: usize = 10;
-const OUT_404: usize = 2;
-fn aiur_fn_404(
-  inp: [G; IN_404],
+const INPUT_SIZE_409: usize = 10;
+const IN_409: usize = 10;
+const OUT_409: usize = 2;
+fn aiur_fn_409(
+  inp: [G; IN_409],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_404], ExecError> {
+) -> Result<[G; OUT_409], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36322,7 +36510,7 @@ fn aiur_fn_404(
     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_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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() {
@@ -36332,33 +36520,33 @@ fn aiur_fn_404(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_404] = [__v_15, __v_19];
-        record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_409] = [__v_15, __v_19];
+        record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[262].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[262].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[262].bump_multiplicity(__i); } let __ret: [G; OUT_262] = unsafe { *(record.function_queries[262].output_at(__i).as_ptr() as *const [G; OUT_262]) }; __ret }, _ => aiur_fn_262(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = [__v_1, __v_2, __v_3, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[267].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[267].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[267].bump_multiplicity(__i); } let __ret: [G; OUT_267] = unsafe { *(record.function_queries[267].output_at(__i).as_ptr() as *const [G; OUT_267]) }; __ret }, _ => aiur_fn_267(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
         let __v_16: G = __r_arr[1];
         match __v_15.as_canonical_u64() {
           1u64 => {
             let __v_17: G = G::from_u64(1);
-            let __ret: [G; OUT_404] = [__v_17, __v_16];
-            record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_409] = [__v_17, __v_16];
+            record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
-            let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[403].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[403].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[403].bump_multiplicity(__i); } let __ret: [G; OUT_403] = unsafe { *(record.function_queries[403].output_at(__i).as_ptr() as *const [G; OUT_403]) }; __ret }, _ => aiur_fn_403(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
-            let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[259].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[259].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[259].bump_multiplicity(__i); } let __ret: [G; OUT_259] = unsafe { *(record.function_queries[259].output_at(__i).as_ptr() as *const [G; OUT_259]) }; __ret }, _ => aiur_fn_259(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = [__v_19]; let __cu = unconstrained; let __hit = record.function_queries[264].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[264].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[264].bump_multiplicity(__i); } let __ret: [G; OUT_264] = unsafe { *(record.function_queries[264].output_at(__i).as_ptr() as *const [G; OUT_264]) }; __ret }, _ => aiur_fn_264(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[399].bump_multiplicity(__i); } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[405].bump_multiplicity(__i); } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__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];
@@ -36371,46 +36559,46 @@ fn aiur_fn_404(
                 if (__v_26 != __v_27) {
                   return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("iota: major's constructor belongs to a different inductive".to_string()) });
                 }
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i); } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_6, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[411].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[411].bump_multiplicity(__i); } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => aiur_fn_411(__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];
                 match __v_28.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__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_255] = { let __args: [G; IN_255] = [__v_8, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_8, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_33: G = __r_arr[0];
-                    let __ret: [G; OUT_404] = [__v_32, __v_33];
-                    record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_409] = [__v_32, __v_33];
+                    record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   1u64 => {
-                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_30, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_30, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
                     let __v_31: G = __r_arr[0];
                     let __v_32: G = (__v_3 + __v_4);
                     let __v_33: G = (__v_2 + __v_32);
-                    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_1, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_1, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
                     let __v_34: G = __r_arr[0];
-                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                     let __v_35: G = __r_arr[0];
                     let __v_36: G = (__v_35 - __v_29);
-                    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_25, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_25, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_786] = { let __args: [G; IN_786] = [__v_1, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                     let __v_40: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_31, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_31, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_41: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_41, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_42, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_42, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_43: G = __r_arr[0];
                     let __v_44: G = G::from_u64(1);
-                    let __ret: [G; OUT_404] = [__v_44, __v_43];
-                    record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_409] = [__v_44, __v_43];
+                    record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -36419,13 +36607,13 @@ fn aiur_fn_404(
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_1, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } };
                 let __v_26: G = __r_arr[0];
                 let __v_27: G = G::from_u64(2);
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_28: G = __r_arr[0];
-                let __ret: [G; OUT_404] = [__v_27, __v_28];
-                record.function_queries[404].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_409] = [__v_27, __v_28];
+                record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -36436,18 +36624,18 @@ fn aiur_fn_404(
   })
 }
 
-const INPUT_SIZE_405: usize = 1;
-const IN_405: usize = 1;
-const OUT_405: usize = 4;
-fn aiur_fn_405(
-  inp: [G; IN_405],
+const INPUT_SIZE_410: usize = 1;
+const IN_410: usize = 1;
+const OUT_410: usize = 4;
+fn aiur_fn_410(
+  inp: [G; IN_410],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_405], ExecError> {
+) -> Result<[G; OUT_410], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -36457,7 +36645,7 @@ fn aiur_fn_405(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -36475,10 +36663,10 @@ fn aiur_fn_405(
         match __v_8.as_canonical_u64() {
           6u64 => {
             let __v_20: G = G::from_u64(1);
-            let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_405] = [__v_20, __v_13, __v_21, __v_2];
-            record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_410] = [__v_20, __v_13, __v_21, __v_2];
+            record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -36520,8 +36708,8 @@ fn aiur_fn_405(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_405] = [__v_20, __v_21, __v_54, __v_57];
-            record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_410] = [__v_20, __v_21, __v_54, __v_57];
+            record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -36565,23 +36753,23 @@ fn aiur_fn_405(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_405] = [__v_7, __v_8, __v_41, __v_44];
-        record.function_queries[405].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_410] = [__v_7, __v_8, __v_41, __v_44];
+        record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_406: usize = 2;
-const IN_406: usize = 2;
-const OUT_406: usize = 3;
-fn aiur_fn_406(
-  inp: [G; IN_406],
+const INPUT_SIZE_411: usize = 2;
+const IN_411: usize = 2;
+const OUT_411: usize = 3;
+fn aiur_fn_411(
+  inp: [G; IN_411],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_406], ExecError> {
+) -> Result<[G; OUT_411], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36599,8 +36787,8 @@ fn aiur_fn_406(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_406] = [__v_7, __v_8, __v_12];
-        record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_411] = [__v_7, __v_8, __v_12];
+        record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -36610,17 +36798,17 @@ fn aiur_fn_406(
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_406] = [__v_8, __v_4, __v_5];
-                record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_411] = [__v_8, __v_4, __v_5];
+                record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[406].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[406].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[406].bump_multiplicity(__i); } let __ret: [G; OUT_406] = unsafe { *(record.function_queries[406].output_at(__i).as_ptr() as *const [G; OUT_406]) }; __ret }, _ => aiur_fn_406(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[411].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[411].bump_multiplicity(__i); } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => aiur_fn_411(__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_406] = [__v_8, __v_9, __v_10];
-                record.function_queries[406].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_411] = [__v_8, __v_9, __v_10];
+                record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -36634,15 +36822,15 @@ fn aiur_fn_406(
   })
 }
 
-const INPUT_SIZE_407: usize = 9;
-const IN_407: usize = 9;
-const OUT_407: usize = 2;
-fn aiur_fn_407(
-  inp: [G; IN_407],
+const INPUT_SIZE_412: usize = 9;
+const IN_412: usize = 9;
+const OUT_412: usize = 2;
+fn aiur_fn_412(
+  inp: [G; IN_412],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_407], ExecError> {
+) -> Result<[G; OUT_412], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36666,8 +36854,8 @@ fn aiur_fn_407(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_407] = [__v_14, __v_18];
-        record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_412] = [__v_14, __v_18];
+        record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -36684,8 +36872,8 @@ fn aiur_fn_407(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_407] = [__v_19, __v_23];
-            record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_412] = [__v_19, __v_23];
+            record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
@@ -36694,7 +36882,7 @@ fn aiur_fn_407(
                 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_408] = { let __args: [G; IN_408] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_0, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__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() {
@@ -36704,12 +36892,12 @@ fn aiur_fn_407(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_407] = [__v_24, __v_28];
-                    record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_412] = [__v_24, __v_28];
+                    record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_25: G = __loaded[0];
@@ -36732,7 +36920,7 @@ fn aiur_fn_407(
                           0u64 => {
                             match __v_29.as_canonical_u64() {
                               0u64 => {
-                                let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_23]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
                                 let __v_39: G = __r_arr[0];
                                 match __v_39.as_canonical_u64() {
                                   1u64 => {
@@ -36741,16 +36929,16 @@ fn aiur_fn_407(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_407] = [__v_40, __v_44];
-                                    record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_412] = [__v_40, __v_44];
+                                    record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
-                                    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                                     let __v_40: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                                     let __v_41: G = __r_arr[0];
-                                    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+                                    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
                                     let __v_42: G = __r_arr[0];
                                     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
                                     let __v_43: G = __r_arr[0];
@@ -36761,14 +36949,14 @@ fn aiur_fn_407(
                                         let __v_46: G = G::from_u64(0);
                                         let __v_47: G = G::from_u64(0);
                                         let __v_48: G = { let __values: [G; 4] = [__v_45, __v_46, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_407] = [__v_44, __v_48];
-                                        record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_412] = [__v_44, __v_48];
+                                        record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                       _ => {
-                                        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_40, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_40, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
                                         let __v_44: G = __r_arr[0];
-                                        let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_44, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } };
+                                        let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_44, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[474].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i); } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => aiur_fn_474(__args, record, io_buffer, __cu)? } };
                                         let __v_45: G = __r_arr[0];
                                         match __v_45.as_canonical_u64() {
                                           1u64 => {
@@ -36777,31 +36965,31 @@ fn aiur_fn_407(
                                             let __v_48: G = G::from_u64(0);
                                             let __v_49: G = G::from_u64(0);
                                             let __v_50: G = { let __values: [G; 4] = [__v_47, __v_48, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_407] = [__v_46, __v_50];
-                                            record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_412] = [__v_46, __v_50];
+                                            record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
-                                            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_12, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
                                             let __v_46: G = __r_arr[0];
                                             let __v_47: G = (__v_3 + __v_4);
                                             let __v_48: G = (__v_47 + __v_5);
-                                            let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_2, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
                                             let __v_49: G = __r_arr[0];
-                                            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_46, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__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_409] = { let __args: [G; IN_409] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_50, __v_23, __v_40, __v_11, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__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_21 + __v_53);
-                                            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_2, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_2, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                                             let __v_55: G = __r_arr[0];
                                             let __v_56: G = G::from_u64(1);
-                                            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_52, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                                            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_52, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                                             let __v_57: G = __r_arr[0];
-                                            let __ret: [G; OUT_407] = [__v_56, __v_57];
-                                            record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_412] = [__v_56, __v_57];
+                                            record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -36816,8 +37004,8 @@ fn aiur_fn_407(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_407] = [__v_39, __v_43];
-                                record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_412] = [__v_39, __v_43];
+                                record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -36828,8 +37016,8 @@ fn aiur_fn_407(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_407] = [__v_39, __v_43];
-                            record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_412] = [__v_39, __v_43];
+                            record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -36840,8 +37028,8 @@ fn aiur_fn_407(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_407] = [__v_37, __v_41];
-                        record.function_queries[407].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_412] = [__v_37, __v_41];
+                        record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -36862,15 +37050,15 @@ fn aiur_fn_407(
   })
 }
 
-const INPUT_SIZE_408: usize = 2;
-const IN_408: usize = 2;
-const OUT_408: usize = 2;
-fn aiur_fn_408(
-  inp: [G; IN_408],
+const INPUT_SIZE_413: usize = 2;
+const IN_413: usize = 2;
+const OUT_413: usize = 2;
+fn aiur_fn_413(
+  inp: [G; IN_413],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_408], ExecError> {
+) -> Result<[G; OUT_413], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -36883,7 +37071,7 @@ fn aiur_fn_408(
         let __v_5: G = __loaded[3];
         match __v_2.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -36894,8 +37082,8 @@ fn aiur_fn_408(
             match __v_8.as_canonical_u64() {
               2u64 => {
                 let __v_12: G = G::from_u64(1);
-                let __ret: [G; OUT_408] = [__v_12, __v_9];
-                record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_413] = [__v_12, __v_9];
+                record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -36933,8 +37121,8 @@ fn aiur_fn_408(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_408] = [__v_12, __v_45];
-                record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_413] = [__v_12, __v_45];
+                record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -36974,8 +37162,8 @@ fn aiur_fn_408(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_408] = [__v_6, __v_39];
-            record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_413] = [__v_6, __v_39];
+            record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -36990,11 +37178,11 @@ fn aiur_fn_408(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_408] = [__v_8, __v_9];
-            record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_413] = [__v_8, __v_9];
+            record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -37032,8 +37220,8 @@ fn aiur_fn_408(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_408] = [__v_6, __v_39];
-            record.function_queries[408].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_413] = [__v_6, __v_39];
+            record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -37042,15 +37230,15 @@ fn aiur_fn_408(
   })
 }
 
-const INPUT_SIZE_409: usize = 5;
-const IN_409: usize = 5;
-const OUT_409: usize = 1;
-fn aiur_fn_409(
-  inp: [G; IN_409],
+const INPUT_SIZE_414: usize = 5;
+const IN_414: usize = 5;
+const OUT_414: usize = 1;
+fn aiur_fn_414(
+  inp: [G; IN_414],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_409], ExecError> {
+) -> Result<[G; OUT_414], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37060,8 +37248,8 @@ fn aiur_fn_409(
     let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_409] = [__v_0];
-        record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_414] = [__v_0];
+        record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -37072,28 +37260,28 @@ fn aiur_fn_409(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_4 + __v_11);
-        let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_409] = [__v_13];
-        record.function_queries[409].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_414] = [__v_13];
+        record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_410: usize = 1;
-const IN_410: usize = 1;
-const OUT_410: usize = 1;
-fn aiur_fn_410(
-  inp: [G; IN_410],
+const INPUT_SIZE_415: usize = 1;
+const IN_415: usize = 1;
+const OUT_415: usize = 1;
+fn aiur_fn_415(
+  inp: [G; IN_415],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_410], ExecError> {
+) -> Result<[G; OUT_415], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -37110,38 +37298,38 @@ fn aiur_fn_410(
     let __v_13: G = __loaded[11];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[411].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[411].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[411].bump_multiplicity(__i); } let __ret: [G; OUT_411] = unsafe { *(record.function_queries[411].output_at(__i).as_ptr() as *const [G; OUT_411]) }; __ret }, _ => aiur_fn_411(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_10, __v_7, __v_5, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_410] = [__v_16];
-        record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_415] = [__v_16];
+        record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(1);
-        let __ret: [G; OUT_410] = [__v_14];
-        record.function_queries[410].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_415] = [__v_14];
+        record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_411: usize = 2;
-const IN_411: usize = 2;
-const OUT_411: usize = 1;
-fn aiur_fn_411(
-  inp: [G; IN_411],
+const INPUT_SIZE_416: usize = 2;
+const IN_416: usize = 2;
+const OUT_416: usize = 1;
+fn aiur_fn_416(
+  inp: [G; IN_416],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_411], ExecError> {
+) -> Result<[G; OUT_416], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -37194,10 +37382,10 @@ fn aiur_fn_411(
       _ => {
         match __v_2.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __ret: [G; OUT_411] = [__v_50];
-            record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_416] = [__v_50];
+            record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -37206,8 +37394,8 @@ fn aiur_fn_411(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_411] = [__v_54];
-            record.function_queries[411].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_416] = [__v_54];
+            record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -37216,15 +37404,15 @@ fn aiur_fn_411(
   })
 }
 
-const INPUT_SIZE_412: usize = 6;
-const IN_412: usize = 6;
-const OUT_412: usize = 1;
-fn aiur_fn_412(
-  inp: [G; IN_412],
+const INPUT_SIZE_417: usize = 6;
+const IN_417: usize = 6;
+const OUT_417: usize = 1;
+fn aiur_fn_417(
+  inp: [G; IN_417],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_412], ExecError> {
+) -> Result<[G; OUT_417], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37236,12 +37424,12 @@ fn aiur_fn_412(
     match __v_6.as_canonical_u64() {
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_412] = [__v_7];
-        record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_417] = [__v_7];
+        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -37258,32 +37446,32 @@ fn aiur_fn_412(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[418].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[418].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[418].bump_multiplicity(__i); } let __ret: [G; OUT_418] = unsafe { *(record.function_queries[418].output_at(__i).as_ptr() as *const [G; OUT_418]) }; __ret }, _ => aiur_fn_418(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             match __v_21.as_canonical_u64() {
               1u64 => {
                 let __v_22: G = G::from_u64(1);
-                let __ret: [G; OUT_412] = [__v_22];
-                record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_417] = [__v_22];
+                record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_22: G = G::from_u64(1);
                 let __v_23: G = (__v_5 + __v_22);
-                let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
                 let __v_24: G = __r_arr[0];
-                let __ret: [G; OUT_412] = [__v_24];
-                record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_417] = [__v_24];
+                record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_20: G = G::from_u64(1);
-            let __ret: [G; OUT_412] = [__v_20];
-            record.function_queries[412].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_417] = [__v_20];
+            record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -37292,22 +37480,22 @@ fn aiur_fn_412(
   })
 }
 
-const INPUT_SIZE_413: usize = 2;
-const IN_413: usize = 2;
-const OUT_413: usize = 1;
-fn aiur_fn_413(
-  inp: [G; IN_413],
+const INPUT_SIZE_418: usize = 2;
+const IN_418: usize = 2;
+const OUT_418: usize = 1;
+fn aiur_fn_418(
+  inp: [G; IN_418],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_413], ExecError> {
+) -> Result<[G; OUT_418], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_413] = [__v_0];
-        record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_418] = [__v_0];
+        record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -37320,15 +37508,15 @@ fn aiur_fn_413(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[418].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[418].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[418].bump_multiplicity(__i); } let __ret: [G; OUT_418] = unsafe { *(record.function_queries[418].output_at(__i).as_ptr() as *const [G; OUT_418]) }; __ret }, _ => aiur_fn_418(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_413] = [__v_8];
-            record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_418] = [__v_8];
+            record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_413] = [__v_0];
-            record.function_queries[413].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_418] = [__v_0];
+            record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -37337,15 +37525,15 @@ fn aiur_fn_413(
   })
 }
 
-const INPUT_SIZE_414: usize = 2;
-const IN_414: usize = 2;
-const OUT_414: usize = 1;
-fn aiur_fn_414(
-  inp: [G; IN_414],
+const INPUT_SIZE_419: usize = 2;
+const IN_419: usize = 2;
+const OUT_419: usize = 1;
+fn aiur_fn_419(
+  inp: [G; IN_419],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_414], ExecError> {
+) -> Result<[G; OUT_419], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37356,43 +37544,43 @@ fn aiur_fn_414(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_414] = [__v_7];
-            record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_419] = [__v_7];
+            record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[414].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[414].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[414].bump_multiplicity(__i); } let __ret: [G; OUT_414] = unsafe { *(record.function_queries[414].output_at(__i).as_ptr() as *const [G; OUT_414]) }; __ret }, _ => aiur_fn_414(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_414] = [__v_7];
-            record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_419] = [__v_7];
+            record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_414] = [__v_6];
-        record.function_queries[414].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_419] = [__v_6];
+        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_415: usize = 2;
-const IN_415: usize = 2;
-const OUT_415: usize = 1;
-fn aiur_fn_415(
-  inp: [G; IN_415],
+const INPUT_SIZE_420: usize = 2;
+const IN_420: usize = 2;
+const OUT_420: usize = 1;
+fn aiur_fn_420(
+  inp: [G; IN_420],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_415], ExecError> {
+) -> Result<[G; OUT_420], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37403,94 +37591,94 @@ fn aiur_fn_415(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[421].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i); } let __ret: [G; OUT_421] = unsafe { *(record.function_queries[421].output_at(__i).as_ptr() as *const [G; OUT_421]) }; __ret }, _ => aiur_fn_421(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_415] = [__v_6];
-        record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_420] = [__v_6];
+        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_415] = [__v_7];
-            record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_420] = [__v_7];
+            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_415] = [__v_8];
-                record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_420] = [__v_8];
+                record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
-                let __ret: [G; OUT_415] = [__v_8];
-                record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_420] = [__v_8];
+                record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -37498,31 +37686,31 @@ fn aiur_fn_415(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_415] = [__v_6];
-        record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_420] = [__v_6];
+        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_415] = [__v_6];
-        record.function_queries[415].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_420] = [__v_6];
+        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_416: usize = 2;
-const IN_416: usize = 2;
-const OUT_416: usize = 1;
-fn aiur_fn_416(
-  inp: [G; IN_416],
+const INPUT_SIZE_421: usize = 2;
+const IN_421: usize = 2;
+const OUT_421: usize = 1;
+fn aiur_fn_421(
+  inp: [G; IN_421],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_416], ExecError> {
+) -> Result<[G; OUT_421], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37533,8 +37721,8 @@ fn aiur_fn_416(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_416] = [__v_5];
-        record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_421] = [__v_5];
+        record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -37543,15 +37731,15 @@ fn aiur_fn_416(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_416] = [__v_6];
-            record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_421] = [__v_6];
+            record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[421].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i); } let __ret: [G; OUT_421] = unsafe { *(record.function_queries[421].output_at(__i).as_ptr() as *const [G; OUT_421]) }; __ret }, _ => aiur_fn_421(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_416] = [__v_6];
-            record.function_queries[416].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_421] = [__v_6];
+            record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -37563,15 +37751,15 @@ fn aiur_fn_416(
   })
 }
 
-const INPUT_SIZE_417: usize = 2;
-const IN_417: usize = 2;
-const OUT_417: usize = 1;
-fn aiur_fn_417(
-  inp: [G; IN_417],
+const INPUT_SIZE_422: usize = 2;
+const IN_422: usize = 2;
+const OUT_422: usize = 1;
+fn aiur_fn_422(
+  inp: [G; IN_422],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_417], ExecError> {
+) -> Result<[G; OUT_422], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37582,80 +37770,80 @@ fn aiur_fn_417(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_417] = [__v_0];
-        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_417] = [__v_0];
-        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_417] = [__v_0];
-        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_417] = [__v_0];
-        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_417] = [__v_0];
-        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_422] = [__v_0];
+        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_417] = [__v_11];
-        record.function_queries[417].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_422] = [__v_11];
+        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_418: usize = 2;
-const IN_418: usize = 2;
-const OUT_418: usize = 1;
-fn aiur_fn_418(
-  inp: [G; IN_418],
+const INPUT_SIZE_423: usize = 2;
+const IN_423: usize = 2;
+const OUT_423: usize = 1;
+fn aiur_fn_423(
+  inp: [G; IN_423],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_418], ExecError> {
+) -> Result<[G; OUT_423], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[377].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[377].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[377].bump_multiplicity(__i); } let __ret: [G; OUT_377] = unsafe { *(record.function_queries[377].output_at(__i).as_ptr() as *const [G; OUT_377]) }; __ret }, _ => aiur_fn_377(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_418] = [__v_5];
-    record.function_queries[418].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_423] = [__v_5];
+    record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_419: usize = 2;
-const IN_419: usize = 2;
-const OUT_419: usize = 1;
-fn aiur_fn_419(
-  inp: [G; IN_419],
+const INPUT_SIZE_424: usize = 2;
+const IN_424: usize = 2;
+const OUT_424: usize = 1;
+fn aiur_fn_424(
+  inp: [G; IN_424],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_419], ExecError> {
+) -> Result<[G; OUT_424], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37666,57 +37854,57 @@ fn aiur_fn_419(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_419] = [__v_0];
-        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_424] = [__v_0];
+        record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_419] = [__v_0];
-        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_424] = [__v_0];
+        record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_419] = [__v_0];
-        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_424] = [__v_0];
+        record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_419] = [__v_0];
-        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_424] = [__v_0];
+        record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_419] = [__v_0];
-        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_424] = [__v_0];
+        record.function_queries[424].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_419] = [__v_11];
-        record.function_queries[419].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_424] = [__v_11];
+        record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_420: usize = 3;
-const IN_420: usize = 3;
-const OUT_420: usize = 1;
-fn aiur_fn_420(
-  inp: [G; IN_420],
+const INPUT_SIZE_425: usize = 3;
+const IN_425: usize = 3;
+const OUT_425: usize = 1;
+fn aiur_fn_425(
+  inp: [G; IN_425],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_420], ExecError> {
+) -> Result<[G; OUT_425], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37728,104 +37916,104 @@ fn aiur_fn_420(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_10];
-        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_425] = [__v_10];
+        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__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 __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_420] = [__v_14];
-            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_425] = [__v_14];
+            record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(0);
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_17, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_420] = [__v_18];
-            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_425] = [__v_18];
+            record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_15, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_420] = [__v_16];
-            record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_425] = [__v_16];
+            record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_9];
-        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_425] = [__v_9];
+        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[421].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i); } let __ret: [G; OUT_421] = unsafe { *(record.function_queries[421].output_at(__i).as_ptr() as *const [G; OUT_421]) }; __ret }, _ => aiur_fn_421(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_4, __v_5, __v_6, __v_1, __v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[426].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => aiur_fn_426(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_7];
-        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_425] = [__v_7];
+        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_7];
-        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_425] = [__v_7];
+        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_420] = [__v_7];
-        record.function_queries[420].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_425] = [__v_7];
+        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_421: usize = 6;
-const IN_421: usize = 6;
-const OUT_421: usize = 1;
-fn aiur_fn_421(
-  inp: [G; IN_421],
+const INPUT_SIZE_426: usize = 6;
+const IN_426: usize = 6;
+const OUT_426: usize = 1;
+fn aiur_fn_426(
+  inp: [G; IN_426],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_421], ExecError> {
+) -> Result<[G; OUT_426], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37833,9 +38021,9 @@ fn aiur_fn_421(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[424].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[424].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => aiur_fn_424(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -37845,7 +38033,7 @@ fn aiur_fn_421(
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_14: G = __loaded[0];
@@ -37863,50 +38051,50 @@ fn aiur_fn_421(
         match __v_14.as_canonical_u64() {
           6u64 => {
             let __v_26: G = (__v_20 + __v_1);
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_8, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[420].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[420].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[420].bump_multiplicity(__i); } let __ret: [G; OUT_420] = unsafe { *(record.function_queries[420].output_at(__i).as_ptr() as *const [G; OUT_420]) }; __ret }, _ => aiur_fn_420(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_27, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_28];
-            record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_426] = [__v_28];
+            record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
-            let __ret: [G; OUT_421] = [__v_26];
-            record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_426] = [__v_26];
+            record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_421] = [__v_13];
-        record.function_queries[421].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_426] = [__v_13];
+        record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_422: usize = 5;
-const IN_422: usize = 5;
-const OUT_422: usize = 1;
-fn aiur_fn_422(
-  inp: [G; IN_422],
+const INPUT_SIZE_427: usize = 5;
+const IN_427: usize = 5;
+const OUT_427: usize = 1;
+fn aiur_fn_427(
+  inp: [G; IN_427],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_422], ExecError> {
+) -> Result<[G; OUT_427], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
@@ -37923,48 +38111,48 @@ fn aiur_fn_422(
     let __v_17: G = __loaded[11];
     match __v_6.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_8, __v_9, __v_11, __v_12, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_3, __v_9, __v_11, __v_12, __v_10, __v_13, __v_4, __v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = __r_arr[1];
         match __v_19.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_20, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[424].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[424].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => aiur_fn_424(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_422] = [__v_21];
-            record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_427] = [__v_21];
+            record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_422] = [__v_21];
-            record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_427] = [__v_21];
+            record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __ret: [G; OUT_422] = [__v_18];
-        record.function_queries[422].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_427] = [__v_18];
+        record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_423: usize = 2;
-const IN_423: usize = 2;
-const OUT_423: usize = 1;
-fn aiur_fn_423(
-  inp: [G; IN_423],
+const INPUT_SIZE_428: usize = 2;
+const IN_428: usize = 2;
+const OUT_428: usize = 1;
+fn aiur_fn_428(
+  inp: [G; IN_428],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_423], ExecError> {
+) -> Result<[G; OUT_428], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -37975,80 +38163,80 @@ fn aiur_fn_423(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_423] = [__v_0];
-        record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_428] = [__v_0];
+        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_423] = [__v_0];
-        record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_428] = [__v_0];
+        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_423] = [__v_0];
-        record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_428] = [__v_0];
+        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_423] = [__v_0];
-        record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_428] = [__v_0];
+        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_423] = [__v_0];
-        record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_428] = [__v_0];
+        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0, __v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_423] = [__v_11];
-        record.function_queries[423].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_428] = [__v_11];
+        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_424: usize = 2;
-const IN_424: usize = 2;
-const OUT_424: usize = 1;
-fn aiur_fn_424(
-  inp: [G; IN_424],
+const INPUT_SIZE_429: usize = 2;
+const IN_429: usize = 2;
+const OUT_429: usize = 1;
+fn aiur_fn_429(
+  inp: [G; IN_429],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_424], ExecError> {
+) -> Result<[G; OUT_429], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_0, __v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_424] = [__v_5];
-    record.function_queries[424].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_429] = [__v_5];
+    record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_425: usize = 3;
-const IN_425: usize = 3;
-const OUT_425: usize = 1;
-fn aiur_fn_425(
-  inp: [G; IN_425],
+const INPUT_SIZE_430: usize = 3;
+const IN_430: usize = 3;
+const OUT_430: usize = 1;
+fn aiur_fn_430(
+  inp: [G; IN_430],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_425], ExecError> {
+) -> Result<[G; OUT_430], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38060,68 +38248,68 @@ fn aiur_fn_425(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       3u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = __r_arr[1];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_8, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_7, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_10];
-        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_430] = [__v_10];
+        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[426].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[426].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[426].bump_multiplicity(__i); } let __ret: [G; OUT_426] = unsafe { *(record.function_queries[426].output_at(__i).as_ptr() as *const [G; OUT_426]) }; __ret }, _ => aiur_fn_426(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_7];
-        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_430] = [__v_7];
+        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_4, __v_5, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[433].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[433].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[433].bump_multiplicity(__i); } let __ret: [G; OUT_433] = unsafe { *(record.function_queries[433].output_at(__i).as_ptr() as *const [G; OUT_433]) }; __ret }, _ => aiur_fn_433(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_7];
-        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_430] = [__v_7];
+        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_9];
-        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_430] = [__v_9];
+        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[427].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[427].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[427].bump_multiplicity(__i); } let __ret: [G; OUT_427] = unsafe { *(record.function_queries[427].output_at(__i).as_ptr() as *const [G; OUT_427]) }; __ret }, _ => aiur_fn_427(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_4, __v_5, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_7];
-        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_430] = [__v_7];
+        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_425] = [__v_7];
-        record.function_queries[425].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_430] = [__v_7];
+        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_426: usize = 3;
-const IN_426: usize = 3;
-const OUT_426: usize = 1;
-fn aiur_fn_426(
-  inp: [G; IN_426],
+const INPUT_SIZE_431: usize = 3;
+const IN_431: usize = 3;
+const OUT_431: usize = 1;
+fn aiur_fn_431(
+  inp: [G; IN_431],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_426], ExecError> {
+) -> Result<[G; OUT_431], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38129,78 +38317,78 @@ fn aiur_fn_426(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[375].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[375].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[375].bump_multiplicity(__i); } let __ret: [G; OUT_375] = unsafe { *(record.function_queries[375].output_at(__i).as_ptr() as *const [G; OUT_375]) }; __ret }, _ => aiur_fn_375(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_1, __v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[380].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[380].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[380].bump_multiplicity(__i); } let __ret: [G; OUT_380] = unsafe { *(record.function_queries[380].output_at(__i).as_ptr() as *const [G; OUT_380]) }; __ret }, _ => aiur_fn_380(__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_775] = { let __args: [G; IN_775] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     match __v_9.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_1, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_426] = [__v_10];
-        record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_431] = [__v_10];
+        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_367] = { let __args: [G; IN_367] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_13, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_426] = [__v_14];
-        record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_431] = [__v_14];
+        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_6, __v_7, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_11, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_426] = [__v_12];
-        record.function_queries[426].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_431] = [__v_12];
+        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_427: usize = 5;
-const IN_427: usize = 5;
-const OUT_427: usize = 1;
-fn aiur_fn_427(
-  inp: [G; IN_427],
+const INPUT_SIZE_432: usize = 5;
+const IN_432: usize = 5;
+const OUT_432: usize = 1;
+fn aiur_fn_432(
+  inp: [G; IN_432],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_427], ExecError> {
+) -> Result<[G; OUT_432], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[231].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[231].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[231].bump_multiplicity(__i); } let __ret: [G; OUT_231] = unsafe { *(record.function_queries[231].output_at(__i).as_ptr() as *const [G; OUT_231]) }; __ret }, _ => aiur_fn_231(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[236].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[236].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[236].bump_multiplicity(__i); } let __ret: [G; OUT_236] = unsafe { *(record.function_queries[236].output_at(__i).as_ptr() as *const [G; OUT_236]) }; __ret }, _ => aiur_fn_236(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = __r_arr[1];
-    let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[385].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[385].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[385].bump_multiplicity(__i); } let __ret: [G; OUT_385] = unsafe { *(record.function_queries[385].output_at(__i).as_ptr() as *const [G; OUT_385]) }; __ret }, _ => aiur_fn_385(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_1, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
     let __v_10: G = __r_arr[1];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_10, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_427] = [__v_11];
-        record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_432] = [__v_11];
+        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -38211,7 +38399,7 @@ fn aiur_fn_427(
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_16: G = __loaded[0];
@@ -38229,21 +38417,21 @@ fn aiur_fn_427(
             match __v_16.as_canonical_u64() {
               6u64 => {
                 let __v_28: G = (__v_22 + __v_1);
-                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_8, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
                 let __v_29: G = __r_arr[0];
-                let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[425].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[425].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[425].bump_multiplicity(__i); } let __ret: [G; OUT_425] = unsafe { *(record.function_queries[425].output_at(__i).as_ptr() as *const [G; OUT_425]) }; __ret }, _ => aiur_fn_425(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_29, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_427] = [__v_30];
-                record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_432] = [__v_30];
+                record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_28: G = G::from_u64(8);
                 let __v_29: G = { let __values: [G; 4] = [__v_28, __v_0, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_29, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_30: G = __r_arr[0];
-                let __ret: [G; OUT_427] = [__v_30];
-                record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_432] = [__v_30];
+                record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -38251,10 +38439,10 @@ fn aiur_fn_427(
           _ => {
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_16, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_427] = [__v_17];
-            record.function_queries[427].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_432] = [__v_17];
+            record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -38263,32 +38451,32 @@ fn aiur_fn_427(
   })
 }
 
-const INPUT_SIZE_428: usize = 5;
-const IN_428: usize = 5;
-const OUT_428: usize = 1;
-fn aiur_fn_428(
-  inp: [G; IN_428],
+const INPUT_SIZE_433: usize = 5;
+const IN_433: usize = 5;
+const OUT_433: usize = 1;
+fn aiur_fn_433(
+  inp: [G; IN_433],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_428], ExecError> {
+) -> Result<[G; OUT_433], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[390].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[390].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[390].bump_multiplicity(__i); } let __ret: [G; OUT_390] = unsafe { *(record.function_queries[390].output_at(__i).as_ptr() as *const [G; OUT_390]) }; __ret }, _ => aiur_fn_390(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[395].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[395].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[395].bump_multiplicity(__i); } let __ret: [G; OUT_395] = unsafe { *(record.function_queries[395].output_at(__i).as_ptr() as *const [G; OUT_395]) }; __ret }, _ => aiur_fn_395(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_5.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i); } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         break '__mc_0 [__v_8, __v_9];
@@ -38304,7 +38492,7 @@ fn aiur_fn_428(
     }
   },
   _ => {
-    let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[391].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[391].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[391].bump_multiplicity(__i); } let __ret: [G; OUT_391] = unsafe { *(record.function_queries[391].output_at(__i).as_ptr() as *const [G; OUT_391]) }; __ret }, _ => aiur_fn_391(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_0, __v_1, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[396].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[396].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[396].bump_multiplicity(__i); } let __ret: [G; OUT_396] = unsafe { *(record.function_queries[396].output_at(__i).as_ptr() as *const [G; OUT_396]) }; __ret }, _ => aiur_fn_396(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     break '__mc_0 [__v_6, __v_7];
@@ -38315,19 +38503,19 @@ fn aiur_fn_428(
     let __v_7: G = __mc_out___mc_0[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_428] = [__v_8];
-        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_433] = [__v_8];
+        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_428] = [__v_7];
-        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_433] = [__v_7];
+        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -38344,43 +38532,43 @@ fn aiur_fn_428(
         let __v_20: G = __loaded[11];
         match __v_9.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_402] = { let __args: [G; IN_402] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[402].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[402].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[402].bump_multiplicity(__i); } let __ret: [G; OUT_402] = unsafe { *(record.function_queries[402].output_at(__i).as_ptr() as *const [G; OUT_402]) }; __ret }, _ => aiur_fn_402(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
             match __v_21.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_428] = [__v_23];
-                record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_433] = [__v_23];
+                record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_428] = [__v_23];
-                record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_433] = [__v_23];
+                record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           4u64 => {
-            let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[392].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[392].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[392].bump_multiplicity(__i); } let __ret: [G; OUT_392] = unsafe { *(record.function_queries[392].output_at(__i).as_ptr() as *const [G; OUT_392]) }; __ret }, _ => aiur_fn_392(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[397].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[397].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[397].bump_multiplicity(__i); } let __ret: [G; OUT_397] = unsafe { *(record.function_queries[397].output_at(__i).as_ptr() as *const [G; OUT_397]) }; __ret }, _ => aiur_fn_397(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
             match __v_21.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_22, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_428] = [__v_23];
-                record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_433] = [__v_23];
+                record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_428] = [__v_23];
-                record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_433] = [__v_23];
+                record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -38391,10 +38579,10 @@ fn aiur_fn_428(
             let __v_23: G = (__v_22 + __v_13);
             let __mc_out___mc_1: [G; 2] = '__mc_1: { match __v_17.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_11, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[408].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[408].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[408].bump_multiplicity(__i); } let __ret: [G; OUT_408] = unsafe { *(record.function_queries[408].output_at(__i).as_ptr() as *const [G; OUT_408]) }; __ret }, _ => aiur_fn_408(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_11, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[413].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[413].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[413].bump_multiplicity(__i); } let __ret: [G; OUT_413] = unsafe { *(record.function_queries[413].output_at(__i).as_ptr() as *const [G; OUT_413]) }; __ret }, _ => aiur_fn_413(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     let __v_25: G = __r_arr[1];
-    let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[400].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[400].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[400].bump_multiplicity(__i); } let __ret: [G; OUT_400] = unsafe { *(record.function_queries[400].output_at(__i).as_ptr() as *const [G; OUT_400]) }; __ret }, _ => aiur_fn_400(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_25, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[405].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[405].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[405].bump_multiplicity(__i); } let __ret: [G; OUT_405] = unsafe { *(record.function_queries[405].output_at(__i).as_ptr() as *const [G; OUT_405]) }; __ret }, _ => aiur_fn_405(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
     let __v_27: G = __r_arr[1];
     break '__mc_1 [__v_26, __v_27];
@@ -38409,46 +38597,46 @@ fn aiur_fn_428(
             let __v_25: G = __mc_out___mc_1[1];
             match __v_24.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_428] = [__v_25];
-                record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_433] = [__v_25];
+                record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_11, __v_12, __v_14, __v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
                 let __v_26: G = __r_arr[0];
-                let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4, __v_2, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[409].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[409].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[409].bump_multiplicity(__i); } let __ret: [G; OUT_409] = unsafe { *(record.function_queries[409].output_at(__i).as_ptr() as *const [G; OUT_409]) }; __ret }, _ => aiur_fn_409(__args, record, io_buffer, __cu)? } };
                 let __v_27: G = __r_arr[0];
                 let __v_28: G = __r_arr[1];
                 match __v_27.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_28, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_28, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
                     let __v_29: G = __r_arr[0];
-                    let __ret: [G; OUT_428] = [__v_29];
-                    record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_433] = [__v_29];
+                    record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   2u64 => {
                     match __v_17.as_canonical_u64() {
                       1u64 => {
-                        let __ret: [G; OUT_428] = [__v_28];
-                        record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_433] = [__v_28];
+                        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[407].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[407].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[407].bump_multiplicity(__i); } let __ret: [G; OUT_407] = unsafe { *(record.function_queries[407].output_at(__i).as_ptr() as *const [G; OUT_407]) }; __ret }, _ => aiur_fn_407(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_11, __v_1, __v_3, __v_12, __v_14, __v_15, __v_13, __v_16, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[412].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[412].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[412].bump_multiplicity(__i); } let __ret: [G; OUT_412] = unsafe { *(record.function_queries[412].output_at(__i).as_ptr() as *const [G; OUT_412]) }; __ret }, _ => aiur_fn_412(__args, record, io_buffer, __cu)? } };
                         let __v_29: G = __r_arr[0];
                         let __v_30: G = __r_arr[1];
                         match __v_29.as_canonical_u64() {
                           1u64 => {
-                            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_30, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_30, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
                             let __v_31: G = __r_arr[0];
-                            let __ret: [G; OUT_428] = [__v_31];
-                            record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_433] = [__v_31];
+                            record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __ret: [G; OUT_428] = [__v_28];
-                            record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_433] = [__v_28];
+                            record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -38456,10 +38644,10 @@ fn aiur_fn_428(
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                     let __v_29: G = __r_arr[0];
-                    let __ret: [G; OUT_428] = [__v_29];
-                    record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_433] = [__v_29];
+                    record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -38467,10 +38655,10 @@ fn aiur_fn_428(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_428] = [__v_21];
-            record.function_queries[428].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_433] = [__v_21];
+            record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -38479,40 +38667,40 @@ fn aiur_fn_428(
   })
 }
 
-const INPUT_SIZE_429: usize = 2;
-const IN_429: usize = 2;
-const OUT_429: usize = 1;
-fn aiur_fn_429(
-  inp: [G; IN_429],
+const INPUT_SIZE_434: usize = 2;
+const IN_434: usize = 2;
+const OUT_434: usize = 1;
+fn aiur_fn_434(
+  inp: [G; IN_434],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_429], ExecError> {
+) -> Result<[G; OUT_434], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = G::from_u64(1);
     let __v_4: G = (__v_1 + __v_3);
     let __v_5: G = G::from_u64(0);
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_429] = [__v_6];
-    record.function_queries[429].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_434] = [__v_6];
+    record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_430: usize = 12;
-const IN_430: usize = 12;
-const OUT_430: usize = 1;
-fn aiur_fn_430(
-  inp: [G; IN_430],
+const INPUT_SIZE_435: usize = 12;
+const IN_435: usize = 12;
+const OUT_435: usize = 1;
+fn aiur_fn_435(
+  inp: [G; IN_435],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_430], ExecError> {
+) -> Result<[G; OUT_435], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38528,43 +38716,43 @@ fn aiur_fn_430(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_430] = [__v_1];
-        record.function_queries[430].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_435] = [__v_1];
+        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -38574,15 +38762,15 @@ fn aiur_fn_430(
   })
 }
 
-const INPUT_SIZE_431: usize = 12;
-const IN_431: usize = 12;
-const OUT_431: usize = 1;
-fn aiur_fn_431(
-  inp: [G; IN_431],
+const INPUT_SIZE_436: usize = 12;
+const IN_436: usize = 12;
+const OUT_436: usize = 1;
+fn aiur_fn_436(
+  inp: [G; IN_436],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_431], ExecError> {
+) -> Result<[G; OUT_436], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38598,43 +38786,43 @@ fn aiur_fn_431(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_431] = [__v_2];
-        record.function_queries[431].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_436] = [__v_2];
+        record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -38644,21 +38832,21 @@ fn aiur_fn_431(
   })
 }
 
-const INPUT_SIZE_432: usize = 2;
-const IN_432: usize = 2;
-const OUT_432: usize = 1;
-fn aiur_fn_432(
-  inp: [G; IN_432],
+const INPUT_SIZE_437: usize = 2;
+const IN_437: usize = 2;
+const OUT_437: usize = 1;
+fn aiur_fn_437(
+  inp: [G; IN_437],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_432], ExecError> {
+) -> Result<[G; OUT_437], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -38667,15 +38855,15 @@ fn aiur_fn_432(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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);
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_432] = [__v_12];
-        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_437] = [__v_12];
+        record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -38683,16 +38871,16 @@ fn aiur_fn_432(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_432] = [__v_14];
-        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_437] = [__v_14];
+        record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -38707,23 +38895,23 @@ fn aiur_fn_432(
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
         let __v_20: G = __loaded[11];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         if (__v_22 != __v_21) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_21.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__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; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__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; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_23, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_23, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_24: G = __r_arr[0];
-        let __ret: [G; OUT_432] = [__v_24];
-        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_437] = [__v_24];
+        record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -38733,14 +38921,14 @@ fn aiur_fn_432(
         match __v_9.as_canonical_u64() {
           5u64 => {
             let __v_13: G = G::from_u64(0);
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_432] = [__v_14];
-            record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_437] = [__v_14];
+            record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_14: G = __loaded[0];
@@ -38750,10 +38938,10 @@ fn aiur_fn_432(
             match __v_14.as_canonical_u64() {
               5u64 => {
                 let __v_18: G = G::from_u64(0);
-                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
                 let __v_19: G = __r_arr[0];
-                let __ret: [G; OUT_432] = [__v_19];
-                record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_437] = [__v_19];
+                record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -38766,67 +38954,67 @@ fn aiur_fn_432(
       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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_432] = [__v_13];
-        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_437] = [__v_13];
+        record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__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_332] = { let __args: [G; IN_332] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_432] = [__v_15];
-        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_437] = [__v_15];
+        record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_432] = [__v_10];
-        record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_437] = [__v_10];
+        record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = []; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_432] = [__v_14];
-            record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_437] = [__v_14];
+            record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = []; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_432] = [__v_14];
-            record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_437] = [__v_14];
+            record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -38835,11 +39023,11 @@ fn aiur_fn_432(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -38852,7 +39040,7 @@ fn aiur_fn_432(
             if (__v_13 != __v_5) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) });
             }
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_17: G = __loaded[0];
@@ -38874,7 +39062,7 @@ fn aiur_fn_432(
                   return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_29.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) });
                 }
                 let __v_30: G = G::from_u64(0);
-                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_24, __v_25, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_24, __v_25, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
                 let __v_31: 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_31.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_32: G = __loaded[0];
@@ -38891,15 +39079,15 @@ fn aiur_fn_432(
                 let __v_43: G = __loaded[11];
                 match __v_32.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_34, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_34, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
                     let __v_44: G = __r_arr[0];
-                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_44, __v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
                     let __v_45: G = __r_arr[0];
                     let __v_46: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_45, __v_6, __v_46, __v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } };
                     let __v_47: G = __r_arr[0];
-                    let __ret: [G; OUT_432] = [__v_47];
-                    record.function_queries[432].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_437] = [__v_47];
+                    record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -38924,15 +39112,15 @@ fn aiur_fn_432(
   })
 }
 
-const INPUT_SIZE_433: usize = 2;
-const IN_433: usize = 2;
-const OUT_433: usize = 1;
-fn aiur_fn_433(
-  inp: [G; IN_433],
+const INPUT_SIZE_438: usize = 2;
+const IN_438: usize = 2;
+const OUT_438: usize = 1;
+fn aiur_fn_438(
+  inp: [G; IN_438],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_433], ExecError> {
+) -> Result<[G; OUT_438], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -38943,15 +39131,15 @@ fn aiur_fn_433(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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);
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_433] = [__v_10];
-        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_438] = [__v_10];
+        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -38959,16 +39147,16 @@ fn aiur_fn_433(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_433] = [__v_12];
-        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_438] = [__v_12];
+        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
@@ -38983,23 +39171,23 @@ fn aiur_fn_433(
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
         let __v_18: G = __loaded[11];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         if (__v_20 != __v_19) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__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; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__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; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
-        let __ret: [G; OUT_433] = [__v_22];
-        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_438] = [__v_22];
+        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
@@ -39009,14 +39197,14 @@ fn aiur_fn_433(
         match __v_7.as_canonical_u64() {
           5u64 => {
             let __v_11: G = G::from_u64(0);
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_9, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_433] = [__v_12];
-            record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_438] = [__v_12];
+            record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_12: G = __loaded[0];
@@ -39026,10 +39214,10 @@ fn aiur_fn_433(
             match __v_12.as_canonical_u64() {
               5u64 => {
                 let __v_16: G = G::from_u64(0);
-                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_14, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
-                let __ret: [G; OUT_433] = [__v_17];
-                record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_438] = [__v_17];
+                record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -39042,67 +39230,67 @@ fn aiur_fn_433(
       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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_433] = [__v_11];
-        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_438] = [__v_11];
+        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__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_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => 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_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_433] = [__v_13];
-        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_438] = [__v_13];
+        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_433] = [__v_8];
-        record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_438] = [__v_8];
+        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         match __v_3.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(2);
-            let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = []; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             let __v_8: G = G::from_u64(1);
             let __v_9: G = 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_433] = [__v_12];
-            record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_438] = [__v_12];
+            record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_6: G = G::from_u64(2);
-            let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = []; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_433] = [__v_12];
-            record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_438] = [__v_12];
+            record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -39111,11 +39299,11 @@ fn aiur_fn_433(
         }
       },
       8u64 => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -39128,7 +39316,7 @@ fn aiur_fn_433(
             if (__v_11 != __v_3) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) });
             }
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
@@ -39150,7 +39338,7 @@ fn aiur_fn_433(
                   return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_27.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) });
                 }
                 let __v_28: G = G::from_u64(0);
-                let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_22, __v_23, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_22, __v_23, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
                 let __v_29: 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_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_30: G = __loaded[0];
@@ -39167,15 +39355,15 @@ fn aiur_fn_433(
                 let __v_41: G = __loaded[11];
                 match __v_30.as_canonical_u64() {
                   6u64 => {
-                    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_32, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_32, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
                     let __v_42: G = __r_arr[0];
-                    let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_42, __v_9, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
                     let __v_43: G = __r_arr[0];
                     let __v_44: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_43, __v_4, __v_44, __v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } };
                     let __v_45: G = __r_arr[0];
-                    let __ret: [G; OUT_433] = [__v_45];
-                    record.function_queries[433].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_438] = [__v_45];
+                    record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -39200,19 +39388,19 @@ fn aiur_fn_433(
   })
 }
 
-const INPUT_SIZE_434: usize = 2;
-const IN_434: usize = 2;
-const OUT_434: usize = 1;
-fn aiur_fn_434(
-  inp: [G; IN_434],
+const INPUT_SIZE_439: usize = 2;
+const IN_439: usize = 2;
+const OUT_439: usize = 1;
+fn aiur_fn_439(
+  inp: [G; IN_439],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_434], ExecError> {
+) -> Result<[G; OUT_439], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -39221,12 +39409,12 @@ fn aiur_fn_434(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_434] = [__v_4];
-        record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_439] = [__v_4];
+        record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -39235,8 +39423,8 @@ fn aiur_fn_434(
         let __v_11: G = __loaded[3];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_434] = [__v_9];
-            record.function_queries[434].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_439] = [__v_9];
+            record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -39248,23 +39436,23 @@ fn aiur_fn_434(
   })
 }
 
-const INPUT_SIZE_435: usize = 3;
-const IN_435: usize = 3;
-const OUT_435: usize = 1;
-fn aiur_fn_435(
-  inp: [G; IN_435],
+const INPUT_SIZE_440: usize = 3;
+const IN_440: usize = 3;
+const OUT_440: usize = 1;
+fn aiur_fn_440(
+  inp: [G; IN_440],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_435], ExecError> {
+) -> Result<[G; OUT_440], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_435] = [__v_0];
-        record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_440] = [__v_0];
+        record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -39282,14 +39470,14 @@ fn aiur_fn_435(
             match __v_7.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
-                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__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_435] = { let __args: [G; IN_435] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_435] = [__v_14];
-                record.function_queries[435].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_440] = [__v_14];
+                record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -39306,15 +39494,15 @@ fn aiur_fn_435(
   })
 }
 
-const INPUT_SIZE_436: usize = 5;
-const IN_436: usize = 5;
-const OUT_436: usize = 1;
-fn aiur_fn_436(
-  inp: [G; IN_436],
+const INPUT_SIZE_441: usize = 5;
+const IN_441: usize = 5;
+const OUT_441: usize = 1;
+fn aiur_fn_441(
+  inp: [G; IN_441],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_436], ExecError> {
+) -> Result<[G; OUT_441], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39331,22 +39519,22 @@ fn aiur_fn_436(
         let __v_9: G = (__v_1 - __v_2);
         match __v_9.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_436] = [__v_6];
-            record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_441] = [__v_6];
+            record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_7, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_2 + __v_14);
-            let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_13, __v_1, __v_15, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
-            let __ret: [G; OUT_436] = [__v_16];
-            record.function_queries[436].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_441] = [__v_16];
+            record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -39358,15 +39546,15 @@ fn aiur_fn_436(
   })
 }
 
-const INPUT_SIZE_437: usize = 2;
-const IN_437: usize = 2;
-const OUT_437: usize = 1;
-fn aiur_fn_437(
-  inp: [G; IN_437],
+const INPUT_SIZE_442: usize = 2;
+const IN_442: usize = 2;
+const OUT_442: usize = 1;
+fn aiur_fn_442(
+  inp: [G; IN_442],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_437], ExecError> {
+) -> Result<[G; OUT_442], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39383,14 +39571,14 @@ fn aiur_fn_437(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_437] = [__v_8];
-            record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_442] = [__v_8];
+            record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_437] = [__v_8];
-            record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_442] = [__v_8];
+            record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -39403,25 +39591,25 @@ fn aiur_fn_437(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_437] = [__v_8];
-            record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_442] = [__v_8];
+            record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_437] = [__v_9];
-                record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_442] = [__v_9];
+                record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_437] = [__v_9];
-                record.function_queries[437].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_442] = [__v_9];
+                record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -39438,15 +39626,15 @@ fn aiur_fn_437(
   })
 }
 
-const INPUT_SIZE_438: usize = 3;
-const IN_438: usize = 3;
-const OUT_438: usize = 1;
-fn aiur_fn_438(
-  inp: [G; IN_438],
+const INPUT_SIZE_443: usize = 3;
+const IN_443: usize = 3;
+const OUT_443: usize = 1;
+fn aiur_fn_443(
+  inp: [G; IN_443],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_438], ExecError> {
+) -> Result<[G; OUT_443], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39455,33 +39643,33 @@ fn aiur_fn_438(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_438] = [__v_4];
-        record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_443] = [__v_4];
+        record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_348] = { let __args: [G; IN_348] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[348].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[348].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[348].bump_multiplicity(__i); } let __ret: [G; OUT_348] = unsafe { *(record.function_queries[348].output_at(__i).as_ptr() as *const [G; OUT_348]) }; __ret }, _ => aiur_fn_348(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_10];
-            record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_443] = [__v_10];
+            record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[439].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[439].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[439].bump_multiplicity(__i); } let __ret: [G; OUT_439] = unsafe { *(record.function_queries[439].output_at(__i).as_ptr() as *const [G; OUT_439]) }; __ret }, _ => aiur_fn_439(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[444].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i); } let __ret: [G; OUT_444] = unsafe { *(record.function_queries[444].output_at(__i).as_ptr() as *const [G; OUT_444]) }; __ret }, _ => aiur_fn_444(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_438] = [__v_7];
-            record.function_queries[438].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_443] = [__v_7];
+            record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -39490,73 +39678,73 @@ fn aiur_fn_438(
   })
 }
 
-const INPUT_SIZE_439: usize = 4;
-const IN_439: usize = 4;
-const OUT_439: usize = 1;
-fn aiur_fn_439(
-  inp: [G; IN_439],
+const INPUT_SIZE_444: usize = 4;
+const IN_444: usize = 4;
+const OUT_444: usize = 1;
+fn aiur_fn_444(
+  inp: [G; IN_444],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_439], ExecError> {
+) -> Result<[G; OUT_444], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => 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_354] = { let __args: [G; IN_354] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_5, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     match __v_10.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_439] = [__v_12];
-        record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_444] = [__v_12];
+        record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__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_362] = { let __args: [G; IN_362] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_1, __v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_353] = { let __args: [G; IN_353] = [__v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
-        let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_12, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __ret: [G; OUT_439] = [__v_18];
-        record.function_queries[439].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_444] = [__v_18];
+        record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_440: usize = 3;
-const IN_440: usize = 3;
-const OUT_440: usize = 1;
-fn aiur_fn_440(
-  inp: [G; IN_440],
+const INPUT_SIZE_445: usize = 3;
+const IN_445: usize = 3;
+const OUT_445: usize = 1;
+fn aiur_fn_445(
+  inp: [G; IN_445],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_440], ExecError> {
+) -> Result<[G; OUT_445], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39564,73 +39752,73 @@ fn aiur_fn_440(
     let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_440] = [__v_4];
-        record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_445] = [__v_4];
+        record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[441].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[441].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[441].bump_multiplicity(__i); } let __ret: [G; OUT_441] = unsafe { *(record.function_queries[441].output_at(__i).as_ptr() as *const [G; OUT_441]) }; __ret }, _ => aiur_fn_441(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_440] = [__v_4];
-        record.function_queries[440].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_445] = [__v_4];
+        record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_441: usize = 3;
-const IN_441: usize = 3;
-const OUT_441: usize = 1;
-fn aiur_fn_441(
-  inp: [G; IN_441],
+const INPUT_SIZE_446: usize = 3;
+const IN_446: usize = 3;
+const OUT_446: usize = 1;
+fn aiur_fn_446(
+  inp: [G; IN_446],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_441], ExecError> {
+) -> Result<[G; OUT_446], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[447].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[447].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[447].bump_multiplicity(__i); } let __ret: [G; OUT_447] = unsafe { *(record.function_queries[447].output_at(__i).as_ptr() as *const [G; OUT_447]) }; __ret }, _ => aiur_fn_447(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_441] = [__v_4];
-        record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_446] = [__v_4];
+        record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[449].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i); } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => aiur_fn_449(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[454].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i); } let __ret: [G; OUT_454] = unsafe { *(record.function_queries[454].output_at(__i).as_ptr() as *const [G; OUT_454]) }; __ret }, _ => aiur_fn_454(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_441] = [__v_4];
-        record.function_queries[441].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_446] = [__v_4];
+        record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_442: usize = 3;
-const IN_442: usize = 3;
-const OUT_442: usize = 1;
-fn aiur_fn_442(
-  inp: [G; IN_442],
+const INPUT_SIZE_447: usize = 3;
+const IN_447: usize = 3;
+const OUT_447: usize = 1;
+fn aiur_fn_447(
+  inp: [G; IN_447],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_442], ExecError> {
+) -> Result<[G; OUT_447], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -39650,33 +39838,33 @@ fn aiur_fn_442(
             let __v_15: G = (__v_8 - __v_12);
             match __v_15.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   0u64 => {
                     let __v_17: G = G::from_u64(0);
-                    let __ret: [G; OUT_442] = [__v_17];
-                    record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_447] = [__v_17];
+                    record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                     let __v_17: G = __r_arr[0];
-                    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                     let __v_18: G = __r_arr[0];
                     let __v_19: G = (__v_17 - __v_18);
                     match __v_19.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
                         let __v_20: G = __r_arr[0];
-                        let __ret: [G; OUT_442] = [__v_20];
-                        record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_447] = [__v_20];
+                        record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_20: G = G::from_u64(0);
-                        let __ret: [G; OUT_442] = [__v_20];
-                        record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_447] = [__v_20];
+                        record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -39685,39 +39873,39 @@ fn aiur_fn_442(
               },
               _ => {
                 let __v_16: G = G::from_u64(0);
-                let __ret: [G; OUT_442] = [__v_16];
-                record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_447] = [__v_16];
+                record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_15: G = G::from_u64(0);
-            let __ret: [G; OUT_442] = [__v_15];
-            record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_447] = [__v_15];
+            record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_442] = [__v_11];
-        record.function_queries[442].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_447] = [__v_11];
+        record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_443: usize = 3;
-const IN_443: usize = 3;
-const OUT_443: usize = 1;
-fn aiur_fn_443(
-  inp: [G; IN_443],
+const INPUT_SIZE_448: usize = 3;
+const IN_448: usize = 3;
+const OUT_448: usize = 1;
+fn aiur_fn_448(
+  inp: [G; IN_448],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_443], ExecError> {
+) -> Result<[G; OUT_448], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -39735,14 +39923,14 @@ fn aiur_fn_443(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_443] = [__v_9];
-            record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_448] = [__v_9];
+            record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_443] = [__v_9];
-            record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_448] = [__v_9];
+            record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -39755,25 +39943,25 @@ fn aiur_fn_443(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_443] = [__v_9];
-            record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_448] = [__v_9];
+            record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(0);
-                let __ret: [G; OUT_443] = [__v_10];
-                record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_448] = [__v_10];
+                record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_443] = [__v_10];
-                record.function_queries[443].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_448] = [__v_10];
+                record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -39790,15 +39978,15 @@ fn aiur_fn_443(
   })
 }
 
-const INPUT_SIZE_444: usize = 1;
-const IN_444: usize = 1;
-const OUT_444: usize = 1;
-fn aiur_fn_444(
-  inp: [G; IN_444],
+const INPUT_SIZE_449: usize = 1;
+const IN_449: usize = 1;
+const OUT_449: usize = 1;
+fn aiur_fn_449(
+  inp: [G; IN_449],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_444], ExecError> {
+) -> Result<[G; OUT_449], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -39810,48 +39998,48 @@ fn aiur_fn_444(
       7u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[133].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[133].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[133].bump_multiplicity(__i); } let __ret: [G; OUT_133] = unsafe { *(record.function_queries[133].output_at(__i).as_ptr() as *const [G; OUT_133]) }; __ret }, _ => aiur_fn_133(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[138].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[138].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[138].bump_multiplicity(__i); } let __ret: [G; OUT_138] = unsafe { *(record.function_queries[138].output_at(__i).as_ptr() as *const [G; OUT_138]) }; __ret }, _ => aiur_fn_138(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_444] = [__v_5];
-            record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_449] = [__v_5];
+            record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_444] = [__v_5];
-            record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_449] = [__v_5];
+            record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = []; let __cu = unconstrained; let __hit = record.function_queries[147].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[147].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[147].bump_multiplicity(__i); } let __ret: [G; OUT_147] = unsafe { *(record.function_queries[147].output_at(__i).as_ptr() as *const [G; OUT_147]) }; __ret }, _ => aiur_fn_147(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = []; let __cu = unconstrained; let __hit = record.function_queries[152].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[152].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[152].bump_multiplicity(__i); } let __ret: [G; OUT_152] = unsafe { *(record.function_queries[152].output_at(__i).as_ptr() as *const [G; OUT_152]) }; __ret }, _ => aiur_fn_152(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_444] = [__v_6];
-        record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_449] = [__v_6];
+        record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_444] = [__v_5];
-        record.function_queries[444].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_449] = [__v_5];
+        record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_445: usize = 1;
-const IN_445: usize = 1;
-const OUT_445: usize = 3;
-fn aiur_fn_445(
-  inp: [G; IN_445],
+const INPUT_SIZE_450: usize = 1;
+const IN_450: usize = 1;
+const OUT_450: usize = 3;
+fn aiur_fn_450(
+  inp: [G; IN_450],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_445], ExecError> {
+) -> Result<[G; OUT_450], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -39867,10 +40055,10 @@ fn aiur_fn_445(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_445] = [__v_5, __v_9, __v_3];
-            record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_450] = [__v_5, __v_9, __v_3];
+            record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -39878,8 +40066,8 @@ fn aiur_fn_445(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8];
-            record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_450] = [__v_5, __v_0, __v_8];
+            record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -39892,21 +40080,21 @@ fn aiur_fn_445(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = []; let __cu = unconstrained; let __hit = record.function_queries[148].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[148].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[148].bump_multiplicity(__i); } let __ret: [G; OUT_148] = unsafe { *(record.function_queries[148].output_at(__i).as_ptr() as *const [G; OUT_148]) }; __ret }, _ => aiur_fn_148(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = []; let __cu = unconstrained; let __hit = record.function_queries[153].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[153].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[153].bump_multiplicity(__i); } let __ret: [G; OUT_153] = unsafe { *(record.function_queries[153].output_at(__i).as_ptr() as *const [G; OUT_153]) }; __ret }, _ => aiur_fn_153(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 let __v_12: G = __r_arr[1];
                 let __v_13: G = __r_arr[2];
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
-                let __ret: [G; OUT_445] = [__v_14, __v_12, __v_15];
-                record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_450] = [__v_14, __v_12, __v_15];
+                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -39914,8 +40102,8 @@ fn aiur_fn_445(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_445] = [__v_11, __v_0, __v_14];
-                record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_450] = [__v_11, __v_0, __v_14];
+                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -39928,7 +40116,7 @@ fn aiur_fn_445(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = []; let __cu = unconstrained; let __hit = record.function_queries[162].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[162].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[162].bump_multiplicity(__i); } let __ret: [G; OUT_162] = unsafe { *(record.function_queries[162].output_at(__i).as_ptr() as *const [G; OUT_162]) }; __ret }, _ => aiur_fn_162(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = []; let __cu = unconstrained; let __hit = record.function_queries[167].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[167].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[167].bump_multiplicity(__i); } let __ret: [G; OUT_167] = unsafe { *(record.function_queries[167].output_at(__i).as_ptr() as *const [G; OUT_167]) }; __ret }, _ => aiur_fn_167(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
@@ -39943,23 +40131,23 @@ fn aiur_fn_445(
                       7u64 => {
                         match __v_16.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__args, record, io_buffer, __cu)? } };
                             let __v_19: G = __r_arr[0];
                             let __v_20: G = __r_arr[1];
                             let __v_21: G = __r_arr[2];
                             match __v_19.as_canonical_u64() {
                               1u64 => {
                                 let __v_22: G = G::from_u64(1);
-                                let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_21, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[118].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[118].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[118].bump_multiplicity(__i); } let __ret: [G; OUT_118] = unsafe { *(record.function_queries[118].output_at(__i).as_ptr() as *const [G; OUT_118]) }; __ret }, _ => aiur_fn_118(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_21, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[123].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[123].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[123].bump_multiplicity(__i); } let __ret: [G; OUT_123] = unsafe { *(record.function_queries[123].output_at(__i).as_ptr() as *const [G; OUT_123]) }; __ret }, _ => aiur_fn_123(__args, record, io_buffer, __cu)? } };
                                 let __v_23: G = __r_arr[0];
-                                let __ret: [G; OUT_445] = [__v_22, __v_20, __v_23];
-                                record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_450] = [__v_22, __v_20, __v_23];
+                                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_22: G = G::from_u64(1);
-                                let __ret: [G; OUT_445] = [__v_22, __v_7, __v_17];
-                                record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_450] = [__v_22, __v_7, __v_17];
+                                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -39969,8 +40157,8 @@ fn aiur_fn_445(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22];
-                            record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_450] = [__v_19, __v_0, __v_22];
+                            record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -39980,8 +40168,8 @@ fn aiur_fn_445(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_445] = [__v_19, __v_0, __v_22];
-                        record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_450] = [__v_19, __v_0, __v_22];
+                        record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -39991,8 +40179,8 @@ fn aiur_fn_445(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_445] = [__v_15, __v_0, __v_18];
-                    record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_450] = [__v_15, __v_0, __v_18];
+                    record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -40002,8 +40190,8 @@ fn aiur_fn_445(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_445] = [__v_13, __v_0, __v_16];
-                record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_450] = [__v_13, __v_0, __v_16];
+                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40013,8 +40201,8 @@ fn aiur_fn_445(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_445] = [__v_9, __v_0, __v_12];
-            record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_450] = [__v_9, __v_0, __v_12];
+            record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -40024,46 +40212,46 @@ fn aiur_fn_445(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_445] = [__v_5, __v_0, __v_8];
-        record.function_queries[445].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_450] = [__v_5, __v_0, __v_8];
+        record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_446: usize = 3;
-const IN_446: usize = 3;
-const OUT_446: usize = 2;
-fn aiur_fn_446(
-  inp: [G; IN_446],
+const INPUT_SIZE_451: usize = 3;
+const IN_451: usize = 3;
+const OUT_451: usize = 2;
+fn aiur_fn_451(
+  inp: [G; IN_451],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_446], ExecError> {
+) -> Result<[G; OUT_451], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[444].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i); } let __ret: [G; OUT_444] = unsafe { *(record.function_queries[444].output_at(__i).as_ptr() as *const [G; OUT_444]) }; __ret }, _ => aiur_fn_444(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[449].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i); } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => aiur_fn_449(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[444].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[444].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[444].bump_multiplicity(__i); } let __ret: [G; OUT_444] = unsafe { *(record.function_queries[444].output_at(__i).as_ptr() as *const [G; OUT_444]) }; __ret }, _ => aiur_fn_444(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[449].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[449].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[449].bump_multiplicity(__i); } let __ret: [G; OUT_449] = unsafe { *(record.function_queries[449].output_at(__i).as_ptr() as *const [G; OUT_449]) }; __ret }, _ => aiur_fn_449(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = (__v_3 * __v_4);
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = G::from_u64(1);
-        let __ret: [G; OUT_446] = [__v_6, __v_7];
-        record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_451] = [__v_6, __v_7];
+        record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__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_445] = { let __args: [G; IN_445] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[445].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[445].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[445].bump_multiplicity(__i); } let __ret: [G; OUT_445] = unsafe { *(record.function_queries[445].output_at(__i).as_ptr() as *const [G; OUT_445]) }; __ret }, _ => aiur_fn_445(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__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];
@@ -40072,27 +40260,27 @@ fn aiur_fn_446(
           0u64 => {
             let __v_13: G = G::from_u64(0);
             let __v_14: G = G::from_u64(0);
-            let __ret: [G; OUT_446] = [__v_13, __v_14];
-            record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_451] = [__v_13, __v_14];
+            record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               0u64 => {
                 let __v_14: G = G::from_u64(0);
                 let __v_15: G = G::from_u64(0);
-                let __ret: [G; OUT_446] = [__v_14, __v_15];
-                record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_451] = [__v_14, __v_15];
+                record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_14: G = G::from_u64(1);
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_7, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_15: G = __r_arr[0];
-                let __ret: [G; OUT_446] = [__v_14, __v_15];
-                record.function_queries[446].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_451] = [__v_14, __v_15];
+                record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40103,48 +40291,48 @@ fn aiur_fn_446(
   })
 }
 
-const INPUT_SIZE_447: usize = 3;
-const IN_447: usize = 3;
-const OUT_447: usize = 1;
-fn aiur_fn_447(
-  inp: [G; IN_447],
+const INPUT_SIZE_452: usize = 3;
+const IN_452: usize = 3;
+const OUT_452: usize = 1;
+fn aiur_fn_452(
+  inp: [G; IN_452],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_447], ExecError> {
+) -> Result<[G; OUT_452], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_447] = [__v_4];
-        record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_452] = [__v_4];
+        record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __ret: [G; OUT_447] = [__v_4];
-        record.function_queries[447].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_452] = [__v_4];
+        record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_448: usize = 3;
-const IN_448: usize = 3;
-const OUT_448: usize = 1;
-fn aiur_fn_448(
-  inp: [G; IN_448],
+const INPUT_SIZE_453: usize = 3;
+const IN_453: usize = 3;
+const OUT_453: usize = 1;
+fn aiur_fn_453(
+  inp: [G; IN_453],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_448], ExecError> {
+) -> Result<[G; OUT_453], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40158,48 +40346,48 @@ fn aiur_fn_448(
       7u64 => {
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[228].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[228].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[228].bump_multiplicity(__i); } let __ret: [G; OUT_228] = unsafe { *(record.function_queries[228].output_at(__i).as_ptr() as *const [G; OUT_228]) }; __ret }, _ => aiur_fn_228(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[233].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[233].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[233].bump_multiplicity(__i); } let __ret: [G; OUT_233] = unsafe { *(record.function_queries[233].output_at(__i).as_ptr() as *const [G; OUT_233]) }; __ret }, _ => aiur_fn_233(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_7, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[235].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[235].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[235].bump_multiplicity(__i); } let __ret: [G; OUT_235] = unsafe { *(record.function_queries[235].output_at(__i).as_ptr() as *const [G; OUT_235]) }; __ret }, _ => aiur_fn_235(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_448] = [__v_9];
-            record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_453] = [__v_9];
+            record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_448] = [__v_7];
-            record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_453] = [__v_7];
+            record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_448] = [__v_7];
-        record.function_queries[448].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_453] = [__v_7];
+        record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_449: usize = 3;
-const IN_449: usize = 3;
-const OUT_449: usize = 1;
-fn aiur_fn_449(
-  inp: [G; IN_449],
+const INPUT_SIZE_454: usize = 3;
+const IN_454: usize = 3;
+const OUT_454: usize = 1;
+fn aiur_fn_454(
+  inp: [G; IN_454],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_449], ExecError> {
+) -> Result<[G; OUT_454], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_3.as_canonical_u64() {
   1u64 => {
@@ -40207,7 +40395,7 @@ fn aiur_fn_449(
     break '__mc_0 [__v_4];
   },
   _ => {
-    let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     break '__mc_0 [__v_4];
   },
@@ -40217,71 +40405,71 @@ fn aiur_fn_449(
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_449] = [__v_5];
-        record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_454] = [__v_5];
+        record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[450].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[450].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[450].bump_multiplicity(__i); } let __ret: [G; OUT_450] = unsafe { *(record.function_queries[450].output_at(__i).as_ptr() as *const [G; OUT_450]) }; __ret }, _ => aiur_fn_450(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[455].bump_multiplicity(__i); } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_449] = [__v_5];
-        record.function_queries[449].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_454] = [__v_5];
+        record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_450: usize = 3;
-const IN_450: usize = 3;
-const OUT_450: usize = 1;
-fn aiur_fn_450(
-  inp: [G; IN_450],
+const INPUT_SIZE_455: usize = 3;
+const IN_455: usize = 3;
+const OUT_455: usize = 1;
+fn aiur_fn_455(
+  inp: [G; IN_455],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_450], ExecError> {
+) -> Result<[G; OUT_455], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[424].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[424].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => aiur_fn_424(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[419].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[419].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[419].bump_multiplicity(__i); } let __ret: [G; OUT_419] = unsafe { *(record.function_queries[419].output_at(__i).as_ptr() as *const [G; OUT_419]) }; __ret }, _ => aiur_fn_419(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[424].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[424].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[424].bump_multiplicity(__i); } let __ret: [G; OUT_424] = unsafe { *(record.function_queries[424].output_at(__i).as_ptr() as *const [G; OUT_424]) }; __ret }, _ => aiur_fn_424(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_450] = [__v_6];
-        record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_455] = [__v_6];
+        record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[452].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => aiur_fn_452(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[457].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[457].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[457].bump_multiplicity(__i); } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => aiur_fn_457(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_450] = [__v_7];
-            record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_455] = [__v_7];
+            record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[447].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[447].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[447].bump_multiplicity(__i); } let __ret: [G; OUT_447] = unsafe { *(record.function_queries[447].output_at(__i).as_ptr() as *const [G; OUT_447]) }; __ret }, _ => aiur_fn_447(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_450] = [__v_8];
-                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_455] = [__v_8];
+                record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_0, __v_1, __v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
-                let __ret: [G; OUT_450] = [__v_8];
-                record.function_queries[450].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_455] = [__v_8];
+                record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40292,58 +40480,58 @@ fn aiur_fn_450(
   })
 }
 
-const INPUT_SIZE_451: usize = 5;
-const IN_451: usize = 5;
-const OUT_451: usize = 1;
-fn aiur_fn_451(
-  inp: [G; IN_451],
+const INPUT_SIZE_456: usize = 5;
+const IN_456: usize = 5;
+const OUT_456: usize = 1;
+fn aiur_fn_456(
+  inp: [G; IN_456],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_451], ExecError> {
+) -> Result<[G; OUT_456], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = (__v_5 - __v_6);
     match __v_7.as_canonical_u64() {
       0u64 => {
         let __v_8: G = G::from_u64(1);
-        let __ret: [G; OUT_451] = [__v_8];
-        record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_456] = [__v_8];
+        record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[452].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[452].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[452].bump_multiplicity(__i); } let __ret: [G; OUT_452] = unsafe { *(record.function_queries[452].output_at(__i).as_ptr() as *const [G; OUT_452]) }; __ret }, _ => aiur_fn_452(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[457].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[457].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[457].bump_multiplicity(__i); } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => aiur_fn_457(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_451] = [__v_9];
-            record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_456] = [__v_9];
+            record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[447].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[447].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[447].bump_multiplicity(__i); } let __ret: [G; OUT_447] = unsafe { *(record.function_queries[447].output_at(__i).as_ptr() as *const [G; OUT_447]) }; __ret }, _ => aiur_fn_447(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               1u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_451] = [__v_10];
-                record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_456] = [__v_10];
+                record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[453].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[453].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[453].bump_multiplicity(__i); } let __ret: [G; OUT_453] = unsafe { *(record.function_queries[453].output_at(__i).as_ptr() as *const [G; OUT_453]) }; __ret }, _ => aiur_fn_453(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_451] = [__v_10];
-                record.function_queries[451].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_456] = [__v_10];
+                record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40354,15 +40542,15 @@ fn aiur_fn_451(
   })
 }
 
-const INPUT_SIZE_452: usize = 3;
-const IN_452: usize = 3;
-const OUT_452: usize = 1;
-fn aiur_fn_452(
-  inp: [G; IN_452],
+const INPUT_SIZE_457: usize = 3;
+const IN_457: usize = 3;
+const OUT_457: usize = 1;
+fn aiur_fn_457(
+  inp: [G; IN_457],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_452], ExecError> {
+) -> Result<[G; OUT_457], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40381,16 +40569,16 @@ fn aiur_fn_452(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_452] = [__v_11];
-            record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_457] = [__v_11];
+            record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_452] = [__v_11];
-            record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_457] = [__v_11];
+            record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -40403,30 +40591,30 @@ fn aiur_fn_452(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = { 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_452] = [__v_14];
-                record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_457] = [__v_14];
+                record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_452] = [__v_12];
-                record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_457] = [__v_12];
+                record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_452] = [__v_11];
-            record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_457] = [__v_11];
+            record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -40439,53 +40627,53 @@ fn aiur_fn_452(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = { 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_452] = [__v_14];
-                record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_457] = [__v_14];
+                record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_452] = [__v_12];
-                record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_457] = [__v_12];
+                record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_452] = [__v_11];
-            record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_457] = [__v_11];
+            record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_452] = [__v_7];
-        record.function_queries[452].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_457] = [__v_7];
+        record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_453: usize = 5;
-const IN_453: usize = 5;
-const OUT_453: usize = 1;
-fn aiur_fn_453(
-  inp: [G; IN_453],
+const INPUT_SIZE_458: usize = 5;
+const IN_458: usize = 5;
+const OUT_458: usize = 1;
+fn aiur_fn_458(
+  inp: [G; IN_458],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_453], ExecError> {
+) -> Result<[G; OUT_458], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40496,78 +40684,78 @@ fn aiur_fn_453(
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_453] = [__v_6];
-        record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_458] = [__v_6];
+        record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_453] = [__v_7];
-            record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_458] = [__v_7];
+            record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => aiur_fn_470(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_453] = [__v_8];
-                record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_458] = [__v_8];
+                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_453] = [__v_9];
-                    record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_458] = [__v_9];
+                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
                     match __v_9.as_canonical_u64() {
                       1u64 => {
                         let __v_10: G = G::from_u64(1);
-                        let __ret: [G; OUT_453] = [__v_10];
-                        record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_458] = [__v_10];
+                        record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } };
                         let __v_10: G = __r_arr[0];
                         let __v_11: G = __r_arr[1];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
-                            let __ret: [G; OUT_453] = [__v_11];
-                            record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_458] = [__v_11];
+                            record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_12: G = G::from_u64(16);
-                            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_12, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
                             let __v_13: G = __r_arr[0];
                             let __v_14: G = __r_arr[1];
                             let __v_15: G = __r_arr[2];
                             match __v_13.as_canonical_u64() {
                               1u64 => {
                                 let __v_16: G = G::from_u64(1);
-                                let __ret: [G; OUT_453] = [__v_16];
-                                record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_458] = [__v_16];
+                                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[454].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[454].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[454].bump_multiplicity(__i); } let __ret: [G; OUT_454] = unsafe { *(record.function_queries[454].output_at(__i).as_ptr() as *const [G; OUT_454]) }; __ret }, _ => aiur_fn_454(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_14, __v_15, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
                                 let __v_16: G = __r_arr[0];
-                                let __ret: [G; OUT_453] = [__v_16];
-                                record.function_queries[453].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_458] = [__v_16];
+                                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -40586,15 +40774,15 @@ fn aiur_fn_453(
   })
 }
 
-const INPUT_SIZE_454: usize = 5;
-const IN_454: usize = 5;
-const OUT_454: usize = 1;
-fn aiur_fn_454(
-  inp: [G; IN_454],
+const INPUT_SIZE_459: usize = 5;
+const IN_459: usize = 5;
+const OUT_459: usize = 1;
+fn aiur_fn_459(
+  inp: [G; IN_459],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_454], ExecError> {
+) -> Result<[G; OUT_459], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40602,31 +40790,31 @@ fn aiur_fn_454(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(8);
-    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_2, __v_3, __v_5, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_6.as_canonical_u64() {
       1u64 => {
         let __v_8: G = G::from_u64(1);
-        let __ret: [G; OUT_454] = [__v_8];
-        record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_459] = [__v_8];
+        record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_454] = [__v_9];
-            record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_459] = [__v_9];
+            record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[460].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[460].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[460].bump_multiplicity(__i); } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => aiur_fn_460(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_454] = [__v_9];
-            record.function_queries[454].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_459] = [__v_9];
+            record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -40635,38 +40823,38 @@ fn aiur_fn_454(
   })
 }
 
-const INPUT_SIZE_455: usize = 3;
-const IN_455: usize = 3;
-const OUT_455: usize = 1;
-fn aiur_fn_455(
-  inp: [G; IN_455],
+const INPUT_SIZE_460: usize = 3;
+const IN_460: usize = 3;
+const OUT_460: usize = 1;
+fn aiur_fn_460(
+  inp: [G; IN_460],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_455], ExecError> {
+) -> Result<[G; OUT_460], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     match __v_7.as_canonical_u64() {
       0u64 => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_455] = [__v_8];
-        record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_460] = [__v_8];
+        record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = (__v_8 - __v_9);
         match __v_10.as_canonical_u64() {
@@ -40692,60 +40880,60 @@ fn aiur_fn_455(
                         let __v_20: G = (__v_13 - __v_17);
                         match __v_20.as_canonical_u64() {
                           0u64 => {
-                            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_14, __v_18, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_14, __v_18, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                             let __v_21: G = __r_arr[0];
                             match __v_21.as_canonical_u64() {
                               1u64 => {
-                                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_4, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[448].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[448].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[448].bump_multiplicity(__i); } let __ret: [G; OUT_448] = unsafe { *(record.function_queries[448].output_at(__i).as_ptr() as *const [G; OUT_448]) }; __ret }, _ => aiur_fn_448(__args, record, io_buffer, __cu)? } };
                                 let __v_22: G = __r_arr[0];
-                                let __ret: [G; OUT_455] = [__v_22];
-                                record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_460] = [__v_22];
+                                record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_22: G = G::from_u64(0);
-                                let __ret: [G; OUT_455] = [__v_22];
-                                record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_460] = [__v_22];
+                                record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
                           },
                           _ => {
                             let __v_21: G = G::from_u64(0);
-                            let __ret: [G; OUT_455] = [__v_21];
-                            record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_460] = [__v_21];
+                            record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_20: G = G::from_u64(0);
-                        let __ret: [G; OUT_455] = [__v_20];
-                        record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_460] = [__v_20];
+                        record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_19: G = G::from_u64(0);
-                    let __ret: [G; OUT_455] = [__v_19];
-                    record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_460] = [__v_19];
+                    record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_15: G = G::from_u64(0);
-                let __ret: [G; OUT_455] = [__v_15];
-                record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_460] = [__v_15];
+                record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_455] = [__v_11];
-            record.function_queries[455].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_460] = [__v_11];
+            record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -40754,45 +40942,45 @@ fn aiur_fn_455(
   })
 }
 
-const INPUT_SIZE_456: usize = 3;
-const IN_456: usize = 3;
-const OUT_456: usize = 1;
-fn aiur_fn_456(
-  inp: [G; IN_456],
+const INPUT_SIZE_461: usize = 3;
+const IN_461: usize = 3;
+const OUT_461: usize = 1;
+fn aiur_fn_461(
+  inp: [G; IN_461],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_456], ExecError> {
+) -> Result<[G; OUT_461], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(8);
-    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_1, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_456] = [__v_6];
-        record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_461] = [__v_6];
+        record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[455].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[455].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[455].bump_multiplicity(__i); } let __ret: [G; OUT_455] = unsafe { *(record.function_queries[455].output_at(__i).as_ptr() as *const [G; OUT_455]) }; __ret }, _ => aiur_fn_455(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[460].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[460].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[460].bump_multiplicity(__i); } let __ret: [G; OUT_460] = unsafe { *(record.function_queries[460].output_at(__i).as_ptr() as *const [G; OUT_460]) }; __ret }, _ => aiur_fn_460(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_456] = [__v_7];
-            record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_461] = [__v_7];
+            record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[457].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[457].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[457].bump_multiplicity(__i); } let __ret: [G; OUT_457] = unsafe { *(record.function_queries[457].output_at(__i).as_ptr() as *const [G; OUT_457]) }; __ret }, _ => aiur_fn_457(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_456] = [__v_7];
-            record.function_queries[456].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_461] = [__v_7];
+            record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -40801,15 +40989,15 @@ fn aiur_fn_456(
   })
 }
 
-const INPUT_SIZE_457: usize = 3;
-const IN_457: usize = 3;
-const OUT_457: usize = 1;
-fn aiur_fn_457(
-  inp: [G; IN_457],
+const INPUT_SIZE_462: usize = 3;
+const IN_462: usize = 3;
+const OUT_462: usize = 1;
+fn aiur_fn_462(
+  inp: [G; IN_462],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_457], ExecError> {
+) -> Result<[G; OUT_462], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40828,51 +41016,51 @@ fn aiur_fn_457(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[456].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[456].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[456].bump_multiplicity(__i); } let __ret: [G; OUT_456] = unsafe { *(record.function_queries[456].output_at(__i).as_ptr() as *const [G; OUT_456]) }; __ret }, _ => aiur_fn_456(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_457] = [__v_12];
-                record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_462] = [__v_12];
+                record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_457] = [__v_12];
-                record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_462] = [__v_12];
+                record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_457] = [__v_11];
-            record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_462] = [__v_11];
+            record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_457] = [__v_7];
-        record.function_queries[457].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_462] = [__v_7];
+        record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_458: usize = 4;
-const IN_458: usize = 4;
-const OUT_458: usize = 2;
-fn aiur_fn_458(
-  inp: [G; IN_458],
+const INPUT_SIZE_463: usize = 4;
+const IN_463: usize = 4;
+const OUT_463: usize = 2;
+fn aiur_fn_463(
+  inp: [G; IN_463],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_458], ExecError> {
+) -> Result<[G; OUT_463], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -40882,8 +41070,8 @@ fn aiur_fn_458(
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_458] = [__v_5, __v_2];
-        record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_463] = [__v_5, __v_2];
+        record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -40905,24 +41093,24 @@ fn aiur_fn_458(
                 match __v_13.as_canonical_u64() {
                   0u64 => {
                     let __v_14: G = G::from_u64(1);
-                    let __ret: [G; OUT_458] = [__v_14, __v_2];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_14, __v_2];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_14: G = G::from_u64(0);
-                    let __ret: [G; OUT_458] = [__v_14, __v_2];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_14, __v_2];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40935,18 +41123,18 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_458] = [__v_13, __v_2];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_2];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40963,28 +41151,28 @@ fn aiur_fn_458(
                 let __v_13: G = __r_arr[0];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
-                    let __ret: [G; OUT_458] = [__v_14, __v_2];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_14, __v_2];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_458] = [__v_14, __v_15];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_14, __v_15];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -40997,32 +41185,32 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_7, __v_11, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
                     let __v_16: G = __r_arr[1];
-                    let __ret: [G; OUT_458] = [__v_15, __v_16];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_15, __v_16];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_458] = [__v_15, __v_14];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_15, __v_14];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -41035,34 +41223,34 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               4u64 => {
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                     let __v_17: G = __r_arr[0];
                     let __v_18: G = __r_arr[1];
-                    let __ret: [G; OUT_458] = [__v_17, __v_18];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_17, __v_18];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_458] = [__v_15, __v_14];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_15, __v_14];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -41075,34 +41263,34 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
                 match __v_13.as_canonical_u64() {
                   1u64 => {
                     let __v_15: G = G::from_u64(0);
                     let __v_16: G = { let __values: [G; 3] = [__v_15, __v_6, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_7, __v_11, __v_14, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                     let __v_17: G = __r_arr[0];
                     let __v_18: G = __r_arr[1];
-                    let __ret: [G; OUT_458] = [__v_17, __v_18];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_17, __v_18];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_15: G = G::from_u64(0);
-                    let __ret: [G; OUT_458] = [__v_15, __v_14];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_15, __v_14];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -41115,18 +41303,18 @@ fn aiur_fn_458(
             let __v_12: G = __loaded[3];
             match __v_9.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_458] = [__v_13, __v_2];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_2];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -41146,47 +41334,47 @@ fn aiur_fn_458(
                     let __v_14: G = (__v_7 - __v_11);
                     match __v_14.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_8, __v_12, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                         let __v_15: G = __r_arr[0];
                         let __v_16: G = __r_arr[1];
-                        let __ret: [G; OUT_458] = [__v_15, __v_16];
-                        record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_463] = [__v_15, __v_16];
+                        record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_15: G = G::from_u64(0);
-                        let __ret: [G; OUT_458] = [__v_15, __v_2];
-                        record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_463] = [__v_15, __v_2];
+                        record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                     let __v_14: G = __r_arr[0];
                     let __v_15: G = __r_arr[1];
-                    let __ret: [G; OUT_458] = [__v_14, __v_15];
-                    record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_463] = [__v_14, __v_15];
+                    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
                 let __v_14: G = __r_arr[1];
-                let __ret: [G; OUT_458] = [__v_13, __v_14];
-                record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_463] = [__v_13, __v_14];
+                record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[459].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[459].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[459].bump_multiplicity(__i); } let __ret: [G; OUT_459] = unsafe { *(record.function_queries[459].output_at(__i).as_ptr() as *const [G; OUT_459]) }; __ret }, _ => aiur_fn_459(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_458] = [__v_9, __v_10];
-            record.function_queries[458].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_463] = [__v_9, __v_10];
+            record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -41195,15 +41383,15 @@ fn aiur_fn_458(
   })
 }
 
-const INPUT_SIZE_459: usize = 4;
-const IN_459: usize = 4;
-const OUT_459: usize = 2;
-fn aiur_fn_459(
-  inp: [G; IN_459],
+const INPUT_SIZE_464: usize = 4;
+const IN_464: usize = 4;
+const OUT_464: usize = 2;
+fn aiur_fn_464(
+  inp: [G; IN_464],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_459], ExecError> {
+) -> Result<[G; OUT_464], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41213,54 +41401,54 @@ fn aiur_fn_459(
       0u64 => {
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_459] = [__v_4, __v_5];
-        record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_464] = [__v_4, __v_5];
+        record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(1);
         let __v_5: G = (__v_2 - __v_4);
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = (__v_6 - __v_7);
         match __v_8.as_canonical_u64() {
           0u64 => {
             let __v_9: G = G::from_u64(1);
-            let __ret: [G; OUT_459] = [__v_9, __v_5];
-            record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_464] = [__v_9, __v_5];
+            record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_6, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_459] = [__v_10, __v_5];
-                record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_464] = [__v_10, __v_5];
+                record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(8);
-                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_6, __v_7, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = __r_arr[1];
                 let __v_14: G = __r_arr[2];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
                     let __v_15: G = G::from_u64(1);
-                    let __ret: [G; OUT_459] = [__v_15, __v_5];
-                    record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_464] = [__v_15, __v_5];
+                    record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[458].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[458].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[458].bump_multiplicity(__i); } let __ret: [G; OUT_458] = unsafe { *(record.function_queries[458].output_at(__i).as_ptr() as *const [G; OUT_458]) }; __ret }, _ => aiur_fn_458(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_13, __v_14, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
                     let __v_15: G = __r_arr[0];
                     let __v_16: G = __r_arr[1];
-                    let __ret: [G; OUT_459] = [__v_15, __v_16];
-                    record.function_queries[459].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_464] = [__v_15, __v_16];
+                    record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -41273,96 +41461,96 @@ fn aiur_fn_459(
   })
 }
 
-const INPUT_SIZE_460: usize = 3;
-const IN_460: usize = 3;
-const OUT_460: usize = 1;
-fn aiur_fn_460(
-  inp: [G; IN_460],
+const INPUT_SIZE_465: usize = 3;
+const IN_465: usize = 3;
+const OUT_465: usize = 1;
+fn aiur_fn_465(
+  inp: [G; IN_465],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_460], ExecError> {
+) -> Result<[G; OUT_465], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = (__v_3 - __v_4);
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_460] = [__v_6];
-        record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_465] = [__v_6];
+        record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_460] = [__v_7];
-            record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_465] = [__v_7];
+            record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[465].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[465].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[465].bump_multiplicity(__i); } let __ret: [G; OUT_465] = unsafe { *(record.function_queries[465].output_at(__i).as_ptr() as *const [G; OUT_465]) }; __ret }, _ => aiur_fn_465(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => aiur_fn_470(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_460] = [__v_8];
-                record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_465] = [__v_8];
+                record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_460] = [__v_9];
-                    record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_465] = [__v_9];
+                    record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[461].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[461].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[461].bump_multiplicity(__i); } let __ret: [G; OUT_461] = unsafe { *(record.function_queries[461].output_at(__i).as_ptr() as *const [G; OUT_461]) }; __ret }, _ => aiur_fn_461(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_4, __v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
                     match __v_9.as_canonical_u64() {
                       1u64 => {
                         let __v_10: G = G::from_u64(1);
-                        let __ret: [G; OUT_460] = [__v_10];
-                        record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_465] = [__v_10];
+                        record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } };
                         let __v_10: G = __r_arr[0];
                         let __v_11: G = __r_arr[1];
                         match __v_10.as_canonical_u64() {
                           1u64 => {
-                            let __ret: [G; OUT_460] = [__v_11];
-                            record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_465] = [__v_11];
+                            record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[464].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[464].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[464].bump_multiplicity(__i); } let __ret: [G; OUT_464] = unsafe { *(record.function_queries[464].output_at(__i).as_ptr() as *const [G; OUT_464]) }; __ret }, _ => aiur_fn_464(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } };
                             let __v_12: G = __r_arr[0];
                             match __v_12.as_canonical_u64() {
                               1u64 => {
                                 let __v_13: G = G::from_u64(1);
-                                let __ret: [G; OUT_460] = [__v_13];
-                                record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_465] = [__v_13];
+                                record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
-                                let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[470].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[470].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[470].bump_multiplicity(__i); } let __ret: [G; OUT_470] = unsafe { *(record.function_queries[470].output_at(__i).as_ptr() as *const [G; OUT_470]) }; __ret }, _ => aiur_fn_470(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_3, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[475].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => aiur_fn_475(__args, record, io_buffer, __cu)? } };
                                 let __v_13: G = __r_arr[0];
-                                let __ret: [G; OUT_460] = [__v_13];
-                                record.function_queries[460].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_465] = [__v_13];
+                                record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -41381,20 +41569,20 @@ fn aiur_fn_460(
   })
 }
 
-const INPUT_SIZE_461: usize = 3;
-const IN_461: usize = 3;
-const OUT_461: usize = 1;
-fn aiur_fn_461(
-  inp: [G; IN_461],
+const INPUT_SIZE_466: usize = 3;
+const IN_466: usize = 3;
+const OUT_466: usize = 1;
+fn aiur_fn_466(
+  inp: [G; IN_466],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_461], ExecError> {
+) -> Result<[G; OUT_466], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -41404,7 +41592,7 @@ fn aiur_fn_461(
     let __v_8: G = __loaded[3];
     match __v_5.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -41421,13 +41609,13 @@ fn aiur_fn_461(
         let __v_21: G = __loaded[11];
         match __v_10.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             let __v_23: G = (__v_16 + __v_17);
             let __v_24: G = (__v_22 - __v_23);
             match __v_24.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_26: G = __loaded[0];
@@ -41452,42 +41640,42 @@ fn aiur_fn_461(
                     match __v_42.as_canonical_u64() {
                       0u64 => {
                         let __v_43: G = G::from_u64(0);
-                        let __ret: [G; OUT_461] = [__v_43];
-                        record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_466] = [__v_43];
+                        record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[463].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[463].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[463].bump_multiplicity(__i); } let __ret: [G; OUT_463] = unsafe { *(record.function_queries[463].output_at(__i).as_ptr() as *const [G; OUT_463]) }; __ret }, _ => aiur_fn_463(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } };
                         let __v_43: G = __r_arr[0];
-                        let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[410].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[410].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[410].bump_multiplicity(__i); } let __ret: [G; OUT_410] = unsafe { *(record.function_queries[410].output_at(__i).as_ptr() as *const [G; OUT_410]) }; __ret }, _ => aiur_fn_410(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[415].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[415].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[415].bump_multiplicity(__i); } let __ret: [G; OUT_415] = unsafe { *(record.function_queries[415].output_at(__i).as_ptr() as *const [G; OUT_415]) }; __ret }, _ => aiur_fn_415(__args, record, io_buffer, __cu)? } };
                         let __v_44: G = __r_arr[0];
                         match __v_44.as_canonical_u64() {
                           1u64 => {
                             let __v_45: G = G::from_u64(0);
-                            let __ret: [G; OUT_461] = [__v_45];
-                            record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_466] = [__v_45];
+                            record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
                             let __v_45: G = __r_arr[0];
-                            let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
                             let __v_46: G = __r_arr[0];
-                            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_45, __v_46, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                             let __v_47: G = __r_arr[0];
                             match __v_47.as_canonical_u64() {
                               0u64 => {
                                 let __v_48: G = G::from_u64(0);
-                                let __ret: [G; OUT_461] = [__v_48];
-                                record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_466] = [__v_48];
+                                record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
                                 let __v_48: G = G::from_u64(0);
-                                let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } };
+                                let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_43, __v_16, __v_17, __v_0, __v_4, __v_48, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } };
                                 let __v_49: G = __r_arr[0];
-                                let __ret: [G; OUT_461] = [__v_49];
-                                record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_466] = [__v_49];
+                                record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -41498,47 +41686,47 @@ fn aiur_fn_461(
                   },
                   _ => {
                     let __v_38: G = G::from_u64(0);
-                    let __ret: [G; OUT_461] = [__v_38];
-                    record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_466] = [__v_38];
+                    record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_25: G = G::from_u64(0);
-                let __ret: [G; OUT_461] = [__v_25];
-                record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_466] = [__v_25];
+                record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_22: G = G::from_u64(0);
-            let __ret: [G; OUT_461] = [__v_22];
-            record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_466] = [__v_22];
+            record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_461] = [__v_9];
-        record.function_queries[461].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_466] = [__v_9];
+        record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_462: usize = 7;
-const IN_462: usize = 7;
-const OUT_462: usize = 1;
-fn aiur_fn_462(
-  inp: [G; IN_462],
+const INPUT_SIZE_467: usize = 7;
+const IN_467: usize = 7;
+const OUT_467: usize = 1;
+fn aiur_fn_467(
+  inp: [G; IN_467],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_462], ExecError> {
+) -> Result<[G; OUT_467], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41551,32 +41739,32 @@ fn aiur_fn_462(
     match __v_7.as_canonical_u64() {
       0u64 => {
         let __v_8: G = G::from_u64(1);
-        let __ret: [G; OUT_462] = [__v_8];
-        record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_467] = [__v_8];
+        record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_8: G = G::from_u64(8);
         let __v_9: G = { let __values: [G; 4] = [__v_8, __v_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_10: G = (__v_1 + __v_5);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_9, __v_11, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         match __v_12.as_canonical_u64() {
           0u64 => {
             let __v_13: G = G::from_u64(0);
-            let __ret: [G; OUT_462] = [__v_13];
-            record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_467] = [__v_13];
+            record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_13: G = G::from_u64(1);
             let __v_14: G = (__v_5 + __v_13);
-            let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[462].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[462].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[462].bump_multiplicity(__i); } let __ret: [G; OUT_462] = unsafe { *(record.function_queries[462].output_at(__i).as_ptr() as *const [G; OUT_462]) }; __ret }, _ => aiur_fn_462(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_14, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[467].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[467].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[467].bump_multiplicity(__i); } let __ret: [G; OUT_467] = unsafe { *(record.function_queries[467].output_at(__i).as_ptr() as *const [G; OUT_467]) }; __ret }, _ => aiur_fn_467(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_462] = [__v_15];
-            record.function_queries[462].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_467] = [__v_15];
+            record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -41585,19 +41773,19 @@ fn aiur_fn_462(
   })
 }
 
-const INPUT_SIZE_463: usize = 2;
-const IN_463: usize = 2;
-const OUT_463: usize = 1;
-fn aiur_fn_463(
-  inp: [G; IN_463],
+const INPUT_SIZE_468: usize = 2;
+const IN_468: usize = 2;
+const OUT_468: usize = 1;
+fn aiur_fn_468(
+  inp: [G; IN_468],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_463], ExecError> {
+) -> Result<[G; OUT_468], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__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];
@@ -41620,25 +41808,25 @@ fn aiur_fn_463(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __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; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_24]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
-    let __ret: [G; OUT_463] = [__v_25];
-    record.function_queries[463].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_468] = [__v_25];
+    record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_464: usize = 3;
-const IN_464: usize = 3;
-const OUT_464: usize = 1;
-fn aiur_fn_464(
-  inp: [G; IN_464],
+const INPUT_SIZE_469: usize = 3;
+const IN_469: usize = 3;
+const OUT_469: usize = 1;
+fn aiur_fn_469(
+  inp: [G; IN_469],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_464], ExecError> {
+) -> Result<[G; OUT_469], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -41658,15 +41846,15 @@ fn aiur_fn_464(
         match __v_7.as_canonical_u64() {
           4u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_464] = [__v_11];
-            record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_469] = [__v_11];
+            record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_464] = [__v_11];
-            record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_469] = [__v_11];
+            record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -41679,16 +41867,16 @@ fn aiur_fn_464(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_8, __v_9, __v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_464] = [__v_11];
-            record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_469] = [__v_11];
+            record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_464] = [__v_11];
-            record.function_queries[464].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_469] = [__v_11];
+            record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -41697,57 +41885,57 @@ fn aiur_fn_464(
   })
 }
 
-const INPUT_SIZE_465: usize = 3;
-const IN_465: usize = 3;
-const OUT_465: usize = 1;
-fn aiur_fn_465(
-  inp: [G; IN_465],
+const INPUT_SIZE_470: usize = 3;
+const IN_470: usize = 3;
+const OUT_470: usize = 1;
+fn aiur_fn_470(
+  inp: [G; IN_470],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_465], ExecError> {
+) -> Result<[G; OUT_470], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[466].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[466].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[466].bump_multiplicity(__i); } let __ret: [G; OUT_466] = unsafe { *(record.function_queries[466].output_at(__i).as_ptr() as *const [G; OUT_466]) }; __ret }, _ => aiur_fn_466(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[471].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => aiur_fn_471(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_465] = [__v_6];
-        record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_470] = [__v_6];
+        record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_465] = [__v_7];
-        record.function_queries[465].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_470] = [__v_7];
+        record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_466: usize = 1;
-const IN_466: usize = 1;
-const OUT_466: usize = 1;
-fn aiur_fn_466(
-  inp: [G; IN_466],
+const INPUT_SIZE_471: usize = 1;
+const IN_471: usize = 1;
+const OUT_471: usize = 1;
+fn aiur_fn_471(
+  inp: [G; IN_471],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_466], ExecError> {
+) -> Result<[G; OUT_471], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -41757,7 +41945,7 @@ fn aiur_fn_466(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -41781,7 +41969,7 @@ fn aiur_fn_466(
                 match __v_21.as_canonical_u64() {
                   0u64 => {
                     let __v_22: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_15, __v_16, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_24: G = __loaded[0];
@@ -41801,114 +41989,114 @@ fn aiur_fn_466(
                         match __v_31.as_canonical_u64() {
                           0u64 => {
                             let __v_36: G = G::from_u64(1);
-                            let __ret: [G; OUT_466] = [__v_36];
-                            record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_471] = [__v_36];
+                            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_36: G = G::from_u64(0);
-                            let __ret: [G; OUT_466] = [__v_36];
-                            record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_471] = [__v_36];
+                            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_36: G = G::from_u64(0);
-                        let __ret: [G; OUT_466] = [__v_36];
-                        record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_471] = [__v_36];
+                        record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_22: G = G::from_u64(0);
-                    let __ret: [G; OUT_466] = [__v_22];
-                    record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_471] = [__v_22];
+                    record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_20: G = G::from_u64(0);
-                let __ret: [G; OUT_466] = [__v_20];
-                record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_471] = [__v_20];
+                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_466] = [__v_20];
-            record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_471] = [__v_20];
+            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_466] = [__v_7];
-        record.function_queries[466].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_471] = [__v_7];
+        record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_467: usize = 3;
-const IN_467: usize = 3;
-const OUT_467: usize = 1;
-fn aiur_fn_467(
-  inp: [G; IN_467],
+const INPUT_SIZE_472: usize = 3;
+const IN_472: usize = 3;
+const OUT_472: usize = 1;
+fn aiur_fn_472(
+  inp: [G; IN_472],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_467], ExecError> {
+) -> Result<[G; OUT_472], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[469].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[469].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[469].bump_multiplicity(__i); } let __ret: [G; OUT_469] = unsafe { *(record.function_queries[469].output_at(__i).as_ptr() as *const [G; OUT_469]) }; __ret }, _ => aiur_fn_469(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_3, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[474].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i); } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => aiur_fn_474(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_467] = [__v_5];
-        record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_472] = [__v_5];
+        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_467] = [__v_6];
-        record.function_queries[467].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_472] = [__v_6];
+        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_468: usize = 4;
-const IN_468: usize = 4;
-const OUT_468: usize = 1;
-fn aiur_fn_468(
-  inp: [G; IN_468],
+const INPUT_SIZE_473: usize = 4;
+const IN_473: usize = 4;
+const OUT_473: usize = 1;
+fn aiur_fn_473(
+  inp: [G; IN_473],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_468], ExecError> {
+) -> Result<[G; OUT_473], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
@@ -41917,19 +42105,19 @@ fn aiur_fn_468(
     let __v_9: G = __loaded[3];
     match __v_6.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         match __v_10.as_canonical_u64() {
           0u64 => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_468] = [__v_11];
-            record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_473] = [__v_11];
+            record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(0);
-            let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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);
@@ -41940,39 +42128,39 @@ fn aiur_fn_468(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_1, __v_20, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_468] = [__v_23];
-            record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_473] = [__v_23];
+            record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_468] = [__v_10];
-        record.function_queries[468].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_473] = [__v_10];
+        record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_469: usize = 2;
-const IN_469: usize = 2;
-const OUT_469: usize = 1;
-fn aiur_fn_469(
-  inp: [G; IN_469],
+const INPUT_SIZE_474: usize = 2;
+const IN_474: usize = 2;
+const OUT_474: usize = 1;
+fn aiur_fn_474(
+  inp: [G; IN_474],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_469], ExecError> {
+) -> Result<[G; OUT_474], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[432].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[432].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[432].bump_multiplicity(__i); } let __ret: [G; OUT_432] = unsafe { *(record.function_queries[432].output_at(__i).as_ptr() as *const [G; OUT_432]) }; __ret }, _ => aiur_fn_432(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -41984,52 +42172,52 @@ fn aiur_fn_469(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_5, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_5, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_469] = [__v_11];
-        record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_474] = [__v_11];
+        record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_469] = [__v_8];
-        record.function_queries[469].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_474] = [__v_8];
+        record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_470: usize = 3;
-const IN_470: usize = 3;
-const OUT_470: usize = 1;
-fn aiur_fn_470(
-  inp: [G; IN_470],
+const INPUT_SIZE_475: usize = 3;
+const IN_475: usize = 3;
+const OUT_475: usize = 1;
+fn aiur_fn_475(
+  inp: [G; IN_475],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_470], ExecError> {
+) -> Result<[G; OUT_475], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[471].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => aiur_fn_471(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __ret: [G; OUT_470] = [__v_3];
-    record.function_queries[470].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_475] = [__v_3];
+    record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_471: usize = 3;
-const IN_471: usize = 3;
-const OUT_471: usize = 1;
-fn aiur_fn_471(
-  inp: [G; IN_471],
+const INPUT_SIZE_476: usize = 3;
+const IN_476: usize = 3;
+const OUT_476: usize = 1;
+fn aiur_fn_476(
+  inp: [G; IN_476],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_471], ExecError> {
+) -> Result<[G; OUT_476], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42052,22 +42240,22 @@ fn aiur_fn_471(
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(1);
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42080,16 +42268,16 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42106,26 +42294,26 @@ fn aiur_fn_471(
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[437].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[437].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[437].bump_multiplicity(__i); } let __ret: [G; OUT_437] = unsafe { *(record.function_queries[437].output_at(__i).as_ptr() as *const [G; OUT_437]) }; __ret }, _ => aiur_fn_437(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[442].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[442].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[442].bump_multiplicity(__i); } let __ret: [G; OUT_442] = unsafe { *(record.function_queries[442].output_at(__i).as_ptr() as *const [G; OUT_442]) }; __ret }, _ => aiur_fn_442(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42138,31 +42326,31 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 match __v_12.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __ret: [G; OUT_471] = [__v_13];
-                    record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_476] = [__v_13];
+                    record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_13: G = G::from_u64(1);
-                    let __ret: [G; OUT_471] = [__v_13];
-                    record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_476] = [__v_13];
+                    record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -42170,10 +42358,10 @@ fn aiur_fn_471(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42186,31 +42374,31 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_14];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[468].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[468].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[468].bump_multiplicity(__i); } let __ret: [G; OUT_468] = unsafe { *(record.function_queries[468].output_at(__i).as_ptr() as *const [G; OUT_468]) }; __ret }, _ => aiur_fn_468(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_4, __v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42223,38 +42411,38 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_4, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               0u64 => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
                 let __v_13: G = { let __values: [G; 3] = [__v_12, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_14];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_14];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_471] = [__v_7];
-        record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_476] = [__v_7];
+        record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
@@ -42265,28 +42453,28 @@ fn aiur_fn_471(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[399].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[399].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[399].bump_multiplicity(__i); } let __ret: [G; OUT_399] = unsafe { *(record.function_queries[399].output_at(__i).as_ptr() as *const [G; OUT_399]) }; __ret }, _ => aiur_fn_399(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[404].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[404].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[404].bump_multiplicity(__i); } let __ret: [G; OUT_404] = unsafe { *(record.function_queries[404].output_at(__i).as_ptr() as *const [G; OUT_404]) }; __ret }, _ => aiur_fn_404(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = (__v_11 - __v_0);
             match __v_12.as_canonical_u64() {
               0u64 => {
                 let __v_13: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_13];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_13];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[471].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[471].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[471].bump_multiplicity(__i); } let __ret: [G; OUT_471] = unsafe { *(record.function_queries[471].output_at(__i).as_ptr() as *const [G; OUT_471]) }; __ret }, _ => aiur_fn_471(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_11, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } };
                 let __v_13: G = __r_arr[0];
-                let __ret: [G; OUT_471] = [__v_13];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_13];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -42308,32 +42496,32 @@ fn aiur_fn_471(
                 let __v_12: G = (__v_5 - __v_9);
                 match __v_12.as_canonical_u64() {
                   0u64 => {
-                    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_6, __v_10, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __ret: [G; OUT_471] = [__v_13];
-                    record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_476] = [__v_13];
+                    record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_13: G = G::from_u64(0);
-                    let __ret: [G; OUT_471] = [__v_13];
-                    record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_476] = [__v_13];
+                    record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_471] = [__v_12];
-                record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_476] = [__v_12];
+                record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_11: G = G::from_u64(0);
-            let __ret: [G; OUT_471] = [__v_11];
-            record.function_queries[471].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_476] = [__v_11];
+            record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42345,15 +42533,15 @@ fn aiur_fn_471(
   })
 }
 
-const INPUT_SIZE_472: usize = 4;
-const IN_472: usize = 4;
-const OUT_472: usize = 3;
-fn aiur_fn_472(
-  inp: [G; IN_472],
+const INPUT_SIZE_477: usize = 4;
+const IN_477: usize = 4;
+const OUT_477: usize = 3;
+fn aiur_fn_477(
+  inp: [G; IN_477],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_472], ExecError> {
+) -> Result<[G; OUT_477], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42362,8 +42550,8 @@ fn aiur_fn_472(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_472] = [__v_4, __v_0, __v_1];
-        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_477] = [__v_4, __v_0, __v_1];
+        record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -42371,46 +42559,46 @@ fn aiur_fn_472(
         match __v_4.as_canonical_u64() {
           0u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_472] = [__v_5, __v_0, __v_1];
-            record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_477] = [__v_5, __v_0, __v_1];
+            record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[446].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[446].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[446].bump_multiplicity(__i); } let __ret: [G; OUT_446] = unsafe { *(record.function_queries[446].output_at(__i).as_ptr() as *const [G; OUT_446]) }; __ret }, _ => aiur_fn_446(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[451].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[451].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[451].bump_multiplicity(__i); } let __ret: [G; OUT_451] = unsafe { *(record.function_queries[451].output_at(__i).as_ptr() as *const [G; OUT_451]) }; __ret }, _ => aiur_fn_451(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __v_6: G = __r_arr[1];
             match __v_5.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_472] = [__v_6, __v_0, __v_1];
-                record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1];
+                record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
                 let __v_10: G = __r_arr[1];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     match __v_10.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[474].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[474].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[474].bump_multiplicity(__i); } let __ret: [G; OUT_474] = unsafe { *(record.function_queries[474].output_at(__i).as_ptr() as *const [G; OUT_474]) }; __ret }, _ => aiur_fn_474(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_7, __v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[479].bump_multiplicity(__i); } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__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 __ret: [G; OUT_472] = [__v_11, __v_12, __v_13];
-                        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_477] = [__v_11, __v_12, __v_13];
+                        record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_7, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__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 __ret: [G; OUT_472] = [__v_11, __v_12, __v_13];
-                        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_477] = [__v_11, __v_12, __v_13];
+                        record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -42418,21 +42606,21 @@ fn aiur_fn_472(
                   _ => {
                     match __v_10.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[479].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[479].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[479].bump_multiplicity(__i); } let __ret: [G; OUT_479] = unsafe { *(record.function_queries[479].output_at(__i).as_ptr() as *const [G; OUT_479]) }; __ret }, _ => aiur_fn_479(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_9, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[484].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[484].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[484].bump_multiplicity(__i); } let __ret: [G; OUT_484] = unsafe { *(record.function_queries[484].output_at(__i).as_ptr() as *const [G; OUT_484]) }; __ret }, _ => aiur_fn_484(__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 __ret: [G; OUT_472] = [__v_11, __v_12, __v_13];
-                        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_477] = [__v_11, __v_12, __v_13];
+                        record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__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 __ret: [G; OUT_472] = [__v_11, __v_12, __v_13];
-                        record.function_queries[472].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_477] = [__v_11, __v_12, __v_13];
+                        record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -42447,15 +42635,15 @@ fn aiur_fn_472(
   })
 }
 
-const INPUT_SIZE_473: usize = 12;
-const IN_473: usize = 12;
-const OUT_473: usize = 1;
-fn aiur_fn_473(
-  inp: [G; IN_473],
+const INPUT_SIZE_478: usize = 12;
+const IN_478: usize = 12;
+const OUT_478: usize = 1;
+fn aiur_fn_478(
+  inp: [G; IN_478],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_473], ExecError> {
+) -> Result<[G; OUT_478], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42471,29 +42659,29 @@ fn aiur_fn_473(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_473] = [__v_5];
-        record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_478] = [__v_5];
+        record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_473] = [__v_12];
-        record.function_queries[473].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_478] = [__v_12];
+        record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_474: usize = 6;
-const IN_474: usize = 6;
-const OUT_474: usize = 3;
-fn aiur_fn_474(
-  inp: [G; IN_474],
+const INPUT_SIZE_479: usize = 6;
+const IN_479: usize = 6;
+const OUT_479: usize = 3;
+fn aiur_fn_479(
+  inp: [G; IN_479],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_474], ExecError> {
+) -> Result<[G; OUT_479], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -42501,7 +42689,7 @@ fn aiur_fn_474(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
@@ -42516,7 +42704,7 @@ fn aiur_fn_474(
     let __v_16: G = __loaded[9];
     let __v_17: G = __loaded[10];
     let __v_18: G = __loaded[11];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_20: G = __loaded[0];
@@ -42531,26 +42719,26 @@ fn aiur_fn_474(
     let __v_29: G = __loaded[9];
     let __v_30: G = __loaded[10];
     let __v_31: G = __loaded[11];
-    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__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; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__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; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
     let __v_32: G = __r_arr[0];
-    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
     match __v_32.as_canonical_u64() {
       0u64 => {
         match __v_33.as_canonical_u64() {
           0u64 => {
             let __v_34: G = G::from_u64(0);
-            let __ret: [G; OUT_474] = [__v_34, __v_2, __v_3];
-            record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_479] = [__v_34, __v_2, __v_3];
+            record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__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 __ret: [G; OUT_474] = [__v_34, __v_35, __v_36];
-            record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_479] = [__v_34, __v_35, __v_36];
+            record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42558,49 +42746,49 @@ fn aiur_fn_474(
       _ => {
         match __v_33.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[475].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => aiur_fn_475(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__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 __ret: [G; OUT_474] = [__v_34, __v_35, __v_36];
-            record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_479] = [__v_34, __v_35, __v_36];
+            record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__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; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__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; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[473].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[473].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[473].bump_multiplicity(__i); } let __ret: [G; OUT_473] = unsafe { *(record.function_queries[473].output_at(__i).as_ptr() as *const [G; OUT_473]) }; __ret }, _ => aiur_fn_473(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[478].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[478].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[478].bump_multiplicity(__i); } let __ret: [G; OUT_478] = unsafe { *(record.function_queries[478].output_at(__i).as_ptr() as *const [G; OUT_478]) }; __ret }, _ => aiur_fn_478(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
             let __v_36: G = { let __a_val = __v_35.as_canonical_u64(); let __b_val = __v_34.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
             match __v_36.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[475].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[475].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[475].bump_multiplicity(__i); } let __ret: [G; OUT_475] = unsafe { *(record.function_queries[475].output_at(__i).as_ptr() as *const [G; OUT_475]) }; __ret }, _ => aiur_fn_475(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[480].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[480].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[480].bump_multiplicity(__i); } let __ret: [G; OUT_480] = unsafe { *(record.function_queries[480].output_at(__i).as_ptr() as *const [G; OUT_480]) }; __ret }, _ => aiur_fn_480(__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 __ret: [G; OUT_474] = [__v_37, __v_38, __v_39];
-                record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_479] = [__v_37, __v_38, __v_39];
+                record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_37: G = { let __a_val = __v_34.as_canonical_u64(); let __b_val = __v_35.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
                 match __v_37.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[476].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[476].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[476].bump_multiplicity(__i); } let __ret: [G; OUT_476] = unsafe { *(record.function_queries[476].output_at(__i).as_ptr() as *const [G; OUT_476]) }; __ret }, _ => aiur_fn_476(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__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 __ret: [G; OUT_474] = [__v_38, __v_39, __v_40];
-                    record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_479] = [__v_38, __v_39, __v_40];
+                    record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__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 __ret: [G; OUT_474] = [__v_38, __v_39, __v_40];
-                    record.function_queries[474].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_479] = [__v_38, __v_39, __v_40];
+                    record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -42613,176 +42801,176 @@ fn aiur_fn_474(
   })
 }
 
-const INPUT_SIZE_475: usize = 4;
-const IN_475: usize = 4;
-const OUT_475: usize = 3;
-fn aiur_fn_475(
-  inp: [G; IN_475],
+const INPUT_SIZE_480: usize = 4;
+const IN_480: usize = 4;
+const OUT_480: usize = 3;
+fn aiur_fn_480(
+  inp: [G; IN_480],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_475], ExecError> {
+) -> Result<[G; OUT_480], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 - __v_7);
-        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_6, __v_1, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
-        let __ret: [G; OUT_475] = [__v_9, __v_10, __v_11];
-        record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_480] = [__v_9, __v_10, __v_11];
+        record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_475] = [__v_6, __v_0, __v_1];
-        record.function_queries[475].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_480] = [__v_6, __v_0, __v_1];
+        record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_476: usize = 4;
-const IN_476: usize = 4;
-const OUT_476: usize = 3;
-fn aiur_fn_476(
-  inp: [G; IN_476],
+const INPUT_SIZE_481: usize = 4;
+const IN_481: usize = 4;
+const OUT_481: usize = 3;
+fn aiur_fn_481(
+  inp: [G; IN_481],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_476], ExecError> {
+) -> Result<[G; OUT_481], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 - __v_7);
-        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_6, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
-        let __ret: [G; OUT_476] = [__v_9, __v_10, __v_11];
-        record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_481] = [__v_9, __v_10, __v_11];
+        record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_476] = [__v_6, __v_0, __v_1];
-        record.function_queries[476].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_481] = [__v_6, __v_0, __v_1];
+        record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_477: usize = 4;
-const IN_477: usize = 4;
-const OUT_477: usize = 3;
-fn aiur_fn_477(
-  inp: [G; IN_477],
+const INPUT_SIZE_482: usize = 4;
+const IN_482: usize = 4;
+const OUT_482: usize = 3;
+fn aiur_fn_482(
+  inp: [G; IN_482],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_477], ExecError> {
+) -> Result<[G; OUT_482], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(1);
             let __v_11: G = (__v_2 - __v_10);
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8, __v_9, __v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__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_477] = [__v_12, __v_13, __v_14];
-            record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_482] = [__v_12, __v_13, __v_14];
+            record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_477] = [__v_8, __v_0, __v_1];
-            record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_482] = [__v_8, __v_0, __v_1];
+            record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_477] = [__v_6, __v_0, __v_1];
-        record.function_queries[477].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_482] = [__v_6, __v_0, __v_1];
+        record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_478: usize = 5;
-const IN_478: usize = 5;
-const OUT_478: usize = 3;
-fn aiur_fn_478(
-  inp: [G; IN_478],
+const INPUT_SIZE_483: usize = 5;
+const IN_483: usize = 5;
+const OUT_483: usize = 3;
+fn aiur_fn_483(
+  inp: [G; IN_483],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_478], ExecError> {
+) -> Result<[G; OUT_483], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 - __v_7);
-        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_6, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
-        let __ret: [G; OUT_478] = [__v_9, __v_10, __v_11];
-        record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_483] = [__v_9, __v_10, __v_11];
+        record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -42797,35 +42985,35 @@ fn aiur_fn_478(
         let __v_17: G = __loaded[9];
         let __v_18: G = __loaded[10];
         let __v_19: G = __loaded[11];
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__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; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__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; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         match __v_20.as_canonical_u64() {
           0u64 => {
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_478] = [__v_21, __v_1, __v_2];
-            record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_483] = [__v_21, __v_1, __v_2];
+            record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[491].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => aiur_fn_491(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
             match __v_21.as_canonical_u64() {
               1u64 => {
                 let __v_23: G = G::from_u64(1);
                 let __v_24: G = (__v_3 - __v_23);
-                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_22, __v_2, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__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 __ret: [G; OUT_478] = [__v_25, __v_26, __v_27];
-                record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_483] = [__v_25, __v_26, __v_27];
+                record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_478] = [__v_23, __v_1, __v_2];
-                record.function_queries[478].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_483] = [__v_23, __v_1, __v_2];
+                record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -42836,38 +43024,38 @@ fn aiur_fn_478(
   })
 }
 
-const INPUT_SIZE_479: usize = 5;
-const IN_479: usize = 5;
-const OUT_479: usize = 3;
-fn aiur_fn_479(
-  inp: [G; IN_479],
+const INPUT_SIZE_484: usize = 5;
+const IN_484: usize = 5;
+const OUT_484: usize = 3;
+fn aiur_fn_484(
+  inp: [G; IN_484],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_479], ExecError> {
+) -> Result<[G; OUT_484], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_5.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_3 - __v_7);
-        let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_6, __v_2, __v_8, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = __r_arr[1];
         let __v_11: G = __r_arr[2];
-        let __ret: [G; OUT_479] = [__v_9, __v_10, __v_11];
-        record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_484] = [__v_9, __v_10, __v_11];
+        record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -42882,35 +43070,35 @@ fn aiur_fn_479(
         let __v_17: G = __loaded[9];
         let __v_18: G = __loaded[10];
         let __v_19: G = __loaded[11];
-        let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__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; let __hit = record.function_queries[481].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[481].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[481].bump_multiplicity(__i); } let __ret: [G; OUT_481] = unsafe { *(record.function_queries[481].output_at(__i).as_ptr() as *const [G; OUT_481]) }; __ret }, _ => aiur_fn_481(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__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; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         match __v_20.as_canonical_u64() {
           0u64 => {
             let __v_21: G = G::from_u64(0);
-            let __ret: [G; OUT_479] = [__v_21, __v_1, __v_2];
-            record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_484] = [__v_21, __v_1, __v_2];
+            record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_2, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[491].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => aiur_fn_491(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
             let __v_22: G = __r_arr[1];
             match __v_21.as_canonical_u64() {
               1u64 => {
                 let __v_23: G = G::from_u64(1);
                 let __v_24: G = (__v_3 - __v_23);
-                let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_22, __v_24, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__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 __ret: [G; OUT_479] = [__v_25, __v_26, __v_27];
-                record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_484] = [__v_25, __v_26, __v_27];
+                record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_479] = [__v_23, __v_1, __v_2];
-                record.function_queries[479].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_484] = [__v_23, __v_1, __v_2];
+                record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -42921,24 +43109,24 @@ fn aiur_fn_479(
   })
 }
 
-const INPUT_SIZE_480: usize = 4;
-const IN_480: usize = 4;
-const OUT_480: usize = 3;
-fn aiur_fn_480(
-  inp: [G; IN_480],
+const INPUT_SIZE_485: usize = 4;
+const IN_485: usize = 4;
+const OUT_485: usize = 3;
+fn aiur_fn_485(
+  inp: [G; IN_485],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_480], ExecError> {
+) -> Result<[G; OUT_485], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[482].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[482].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[482].bump_multiplicity(__i); } let __ret: [G; OUT_482] = unsafe { *(record.function_queries[482].output_at(__i).as_ptr() as *const [G; OUT_482]) }; __ret }, _ => aiur_fn_482(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     let __v_7: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
@@ -42947,23 +43135,23 @@ fn aiur_fn_480(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 - __v_8);
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_5, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__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_480] = [__v_10, __v_11, __v_12];
-            record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_485] = [__v_10, __v_11, __v_12];
+            record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 - __v_8);
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_5, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__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_480] = [__v_10, __v_11, __v_12];
-            record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_485] = [__v_10, __v_11, __v_12];
+            record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42973,18 +43161,18 @@ fn aiur_fn_480(
           1u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 - __v_8);
-            let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[472].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[472].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[472].bump_multiplicity(__i); } let __ret: [G; OUT_472] = unsafe { *(record.function_queries[472].output_at(__i).as_ptr() as *const [G; OUT_472]) }; __ret }, _ => aiur_fn_472(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_7, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[477].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[477].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[477].bump_multiplicity(__i); } let __ret: [G; OUT_477] = unsafe { *(record.function_queries[477].output_at(__i).as_ptr() as *const [G; OUT_477]) }; __ret }, _ => aiur_fn_477(__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_480] = [__v_10, __v_11, __v_12];
-            record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_485] = [__v_10, __v_11, __v_12];
+            record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_480] = [__v_8, __v_0, __v_1];
-            record.function_queries[480].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_485] = [__v_8, __v_0, __v_1];
+            record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -42993,15 +43181,15 @@ fn aiur_fn_480(
   })
 }
 
-const INPUT_SIZE_481: usize = 12;
-const IN_481: usize = 12;
-const OUT_481: usize = 1;
-fn aiur_fn_481(
-  inp: [G; IN_481],
+const INPUT_SIZE_486: usize = 12;
+const IN_486: usize = 12;
+const OUT_486: usize = 1;
+fn aiur_fn_486(
+  inp: [G; IN_486],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_481], ExecError> {
+) -> Result<[G; OUT_486], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43018,39 +43206,39 @@ fn aiur_fn_481(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_481] = [__v_12];
-        record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_486] = [__v_12];
+        record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_481] = [__v_12];
-        record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_486] = [__v_12];
+        record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_481] = [__v_12];
-        record.function_queries[481].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_486] = [__v_12];
+        record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_482: usize = 2;
-const IN_482: usize = 2;
-const OUT_482: usize = 2;
-fn aiur_fn_482(
-  inp: [G; IN_482],
+const INPUT_SIZE_487: usize = 2;
+const IN_487: usize = 2;
+const OUT_487: usize = 2;
+fn aiur_fn_487(
+  inp: [G; IN_487],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_482], ExecError> {
+) -> Result<[G; OUT_487], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     let __v_3: G = __r_arr[1];
     let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -43060,9 +43248,9 @@ fn aiur_fn_482(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       8u64 => {
-        let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -43072,7 +43260,7 @@ fn aiur_fn_482(
         let __v_14: G = __loaded[3];
         match __v_11.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
             match __v_15.as_canonical_u64() {
@@ -43080,50 +43268,50 @@ fn aiur_fn_482(
                 let __v_17: G = G::from_u64(8);
                 let __v_18: G = { let __values: [G; 4] = [__v_17, __v_5, __v_6, __v_16]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(1);
-                let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_18, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_18, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
                 let __v_20: G = __r_arr[0];
-                let __ret: [G; OUT_482] = [__v_19, __v_20];
-                record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_487] = [__v_19, __v_20];
+                record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_17: G = G::from_u64(0);
-                let __ret: [G; OUT_482] = [__v_17, __v_0];
-                record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_487] = [__v_17, __v_0];
+                record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
             let __v_15: G = G::from_u64(1);
-            let __ret: [G; OUT_482] = [__v_15, __v_8];
-            record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_487] = [__v_15, __v_8];
+            record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __ret: [G; OUT_482] = [__v_8, __v_0];
-        record.function_queries[482].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_487] = [__v_8, __v_0];
+        record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_483: usize = 1;
-const IN_483: usize = 1;
-const OUT_483: usize = 2;
-fn aiur_fn_483(
-  inp: [G; IN_483],
+const INPUT_SIZE_488: usize = 1;
+const IN_488: usize = 1;
+const OUT_488: usize = 2;
+fn aiur_fn_488(
+  inp: [G; IN_488],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_483], ExecError> {
+) -> Result<[G; OUT_488], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -43133,7 +43321,7 @@ fn aiur_fn_483(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -43150,79 +43338,79 @@ fn aiur_fn_483(
         let __v_19: G = __loaded[11];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_483] = [__v_21, __v_22];
-            record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_488] = [__v_21, __v_22];
+            record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_11, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
             let __v_20: G = __r_arr[0];
             let __v_21: G = G::from_u64(1);
-            let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_20, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __ret: [G; OUT_483] = [__v_21, __v_22];
-            record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_488] = [__v_21, __v_22];
+            record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_20: G = G::from_u64(0);
-            let __ret: [G; OUT_483] = [__v_20, __v_0];
-            record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_488] = [__v_20, __v_0];
+            record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_483] = [__v_7, __v_0];
-        record.function_queries[483].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_488] = [__v_7, __v_0];
+        record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_484: usize = 3;
-const IN_484: usize = 3;
-const OUT_484: usize = 1;
-fn aiur_fn_484(
-  inp: [G; IN_484],
+const INPUT_SIZE_489: usize = 3;
+const IN_489: usize = 3;
+const OUT_489: usize = 1;
+fn aiur_fn_489(
+  inp: [G; IN_489],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_484], ExecError> {
+) -> Result<[G; OUT_489], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[485].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[485].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[485].bump_multiplicity(__i); } let __ret: [G; OUT_485] = unsafe { *(record.function_queries[485].output_at(__i).as_ptr() as *const [G; OUT_485]) }; __ret }, _ => aiur_fn_485(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = __r_arr[1];
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_484] = [__v_7];
-        record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_489] = [__v_7];
+        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_484] = [__v_7];
-            record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_489] = [__v_7];
+            record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_8: G = __loaded[0];
@@ -43237,7 +43425,7 @@ fn aiur_fn_484(
             let __v_17: G = __loaded[9];
             let __v_18: G = __loaded[10];
             let __v_19: G = __loaded[11];
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_21: G = __loaded[0];
@@ -43252,27 +43440,27 @@ fn aiur_fn_484(
             let __v_30: G = __loaded[9];
             let __v_31: G = __loaded[10];
             let __v_32: G = __loaded[11];
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[491].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => aiur_fn_491(__args, record, io_buffer, __cu)? } };
             let __v_33: G = __r_arr[0];
             let __v_34: G = __r_arr[1];
-            let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[486].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[486].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[486].bump_multiplicity(__i); } let __ret: [G; OUT_486] = unsafe { *(record.function_queries[486].output_at(__i).as_ptr() as *const [G; OUT_486]) }; __ret }, _ => aiur_fn_486(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_1, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[491].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[491].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[491].bump_multiplicity(__i); } let __ret: [G; OUT_491] = unsafe { *(record.function_queries[491].output_at(__i).as_ptr() as *const [G; OUT_491]) }; __ret }, _ => aiur_fn_491(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
             match __v_33.as_canonical_u64() {
               1u64 => {
                 match __v_35.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_34, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                     let __v_37: G = __r_arr[0];
-                    let __ret: [G; OUT_484] = [__v_37];
-                    record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_489] = [__v_37];
+                    record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_34, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                     let __v_37: G = __r_arr[0];
-                    let __ret: [G; OUT_484] = [__v_37];
-                    record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_489] = [__v_37];
+                    record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -43280,16 +43468,16 @@ fn aiur_fn_484(
               0u64 => {
                 match __v_35.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_36, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                     let __v_37: G = __r_arr[0];
-                    let __ret: [G; OUT_484] = [__v_37];
-                    record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_489] = [__v_37];
+                    record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_37: G = G::from_u64(0);
-                    let __ret: [G; OUT_484] = [__v_37];
-                    record.function_queries[484].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_489] = [__v_37];
+                    record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -43305,18 +43493,18 @@ fn aiur_fn_484(
   })
 }
 
-const INPUT_SIZE_485: usize = 1;
-const IN_485: usize = 1;
-const OUT_485: usize = 2;
-fn aiur_fn_485(
-  inp: [G; IN_485],
+const INPUT_SIZE_490: usize = 1;
+const IN_490: usize = 1;
+const OUT_490: usize = 2;
+fn aiur_fn_490(
+  inp: [G; IN_490],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_485], ExecError> {
+) -> Result<[G; OUT_490], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -43327,8 +43515,8 @@ fn aiur_fn_485(
     match __v_3.as_canonical_u64() {
       2u64 => {
         let __v_7: G = G::from_u64(1);
-        let __ret: [G; OUT_485] = [__v_4, __v_7];
-        record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_490] = [__v_4, __v_7];
+        record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -43366,23 +43554,23 @@ fn aiur_fn_485(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_40: G = G::from_u64(0);
-        let __ret: [G; OUT_485] = [__v_39, __v_40];
-        record.function_queries[485].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_490] = [__v_39, __v_40];
+        record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_486: usize = 14;
-const IN_486: usize = 14;
-const OUT_486: usize = 2;
-fn aiur_fn_486(
-  inp: [G; IN_486],
+const INPUT_SIZE_491: usize = 14;
+const IN_491: usize = 14;
+const OUT_491: usize = 2;
+fn aiur_fn_491(
+  inp: [G; IN_491],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_486], ExecError> {
+) -> Result<[G; OUT_491], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43400,154 +43588,154 @@ fn aiur_fn_486(
     let __v_13: G = inp[13];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
             let __v_16: G = G::from_u64(1);
-            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_486] = [__v_16, __v_17];
-            record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_491] = [__v_16, __v_17];
+            record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_16: G = G::from_u64(0);
-            let __ret: [G; OUT_486] = [__v_16, __v_0];
-            record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_491] = [__v_16, __v_0];
+            record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
-        let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[483].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[483].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[483].bump_multiplicity(__i); } let __ret: [G; OUT_483] = unsafe { *(record.function_queries[483].output_at(__i).as_ptr() as *const [G; OUT_483]) }; __ret }, _ => aiur_fn_483(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
           1u64 => {
             let __v_16: G = G::from_u64(1);
-            let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[423].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[423].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[423].bump_multiplicity(__i); } let __ret: [G; OUT_423] = unsafe { *(record.function_queries[423].output_at(__i).as_ptr() as *const [G; OUT_423]) }; __ret }, _ => aiur_fn_423(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_15, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[428].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[428].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[428].bump_multiplicity(__i); } let __ret: [G; OUT_428] = unsafe { *(record.function_queries[428].output_at(__i).as_ptr() as *const [G; OUT_428]) }; __ret }, _ => aiur_fn_428(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_486] = [__v_16, __v_17];
-            record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_491] = [__v_16, __v_17];
+            record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_16: G = G::from_u64(0);
-            let __ret: [G; OUT_486] = [__v_16, __v_0];
-            record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_491] = [__v_16, __v_0];
+            record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_486] = [__v_14, __v_0];
-        record.function_queries[486].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_491] = [__v_14, __v_0];
+        record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_487: usize = 2;
-const IN_487: usize = 2;
-const OUT_487: usize = 1;
-fn aiur_fn_487(
-  inp: [G; IN_487],
+const INPUT_SIZE_492: usize = 2;
+const IN_492: usize = 2;
+const OUT_492: usize = 1;
+fn aiur_fn_492(
+  inp: [G; IN_492],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_487], ExecError> {
+) -> Result<[G; OUT_492], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_487] = [__v_6];
-        record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_492] = [__v_6];
+        record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[488].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[488].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[488].bump_multiplicity(__i); } let __ret: [G; OUT_488] = unsafe { *(record.function_queries[488].output_at(__i).as_ptr() as *const [G; OUT_488]) }; __ret }, _ => aiur_fn_488(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[493].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[493].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[493].bump_multiplicity(__i); } let __ret: [G; OUT_493] = unsafe { *(record.function_queries[493].output_at(__i).as_ptr() as *const [G; OUT_493]) }; __ret }, _ => aiur_fn_493(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_487] = [__v_3];
-        record.function_queries[487].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_492] = [__v_3];
+        record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_488: usize = 3;
-const IN_488: usize = 3;
-const OUT_488: usize = 1;
-fn aiur_fn_488(
-  inp: [G; IN_488],
+const INPUT_SIZE_493: usize = 3;
+const IN_493: usize = 3;
+const OUT_493: usize = 1;
+fn aiur_fn_493(
+  inp: [G; IN_493],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_488], ExecError> {
+) -> Result<[G; OUT_493], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[350].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[350].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[350].bump_multiplicity(__i); } let __ret: [G; OUT_350] = unsafe { *(record.function_queries[350].output_at(__i).as_ptr() as *const [G; OUT_350]) }; __ret }, _ => aiur_fn_350(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_488] = [__v_8];
-        record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_493] = [__v_8];
+        record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
         let __v_10: G = (__v_2 - __v_6);
-        let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[353].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[353].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[353].bump_multiplicity(__i); } let __ret: [G; OUT_353] = unsafe { *(record.function_queries[353].output_at(__i).as_ptr() as *const [G; OUT_353]) }; __ret }, _ => aiur_fn_353(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[489].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[489].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[489].bump_multiplicity(__i); } let __ret: [G; OUT_489] = unsafe { *(record.function_queries[489].output_at(__i).as_ptr() as *const [G; OUT_489]) }; __ret }, _ => aiur_fn_489(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__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_358] = { let __args: [G; IN_358] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_12, __v_6, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_488] = [__v_14];
-        record.function_queries[488].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_493] = [__v_14];
+        record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_489: usize = 2;
-const IN_489: usize = 2;
-const OUT_489: usize = 1;
-fn aiur_fn_489(
-  inp: [G; IN_489],
+const INPUT_SIZE_494: usize = 2;
+const IN_494: usize = 2;
+const OUT_494: usize = 1;
+fn aiur_fn_494(
+  inp: [G; IN_494],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_489], ExecError> {
+) -> Result<[G; OUT_494], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43558,15 +43746,15 @@ fn aiur_fn_489(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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);
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_10];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_10];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -43574,16 +43762,16 @@ fn aiur_fn_489(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[333].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[333].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[333].bump_multiplicity(__i); } let __ret: [G; OUT_333] = unsafe { *(record.function_queries[333].output_at(__i).as_ptr() as *const [G; OUT_333]) }; __ret }, _ => aiur_fn_333(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_489] = [__v_12];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_12];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_7: G = __loaded[0];
@@ -43598,85 +43786,85 @@ fn aiur_fn_489(
         let __v_16: G = __loaded[9];
         let __v_17: G = __loaded[10];
         let __v_18: G = __loaded[11];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         if (__v_20 != __v_19) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__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; let __hit = record.function_queries[431].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[431].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[431].bump_multiplicity(__i); } let __ret: [G; OUT_431] = unsafe { *(record.function_queries[431].output_at(__i).as_ptr() as *const [G; OUT_431]) }; __ret }, _ => aiur_fn_431(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__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; let __hit = record.function_queries[436].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[436].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[436].bump_multiplicity(__i); } let __ret: [G; OUT_436] = unsafe { *(record.function_queries[436].output_at(__i).as_ptr() as *const [G; OUT_436]) }; __ret }, _ => aiur_fn_436(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_21, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_22];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_22];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_8, __v_7, __v_11, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[506].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => aiur_fn_506(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_12];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_12];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_489] = [__v_12];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_12];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__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_332] = { let __args: [G; IN_332] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => 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_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_489] = [__v_13];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_13];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[490].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[490].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[490].bump_multiplicity(__i); } let __ret: [G; OUT_490] = unsafe { *(record.function_queries[490].output_at(__i).as_ptr() as *const [G; OUT_490]) }; __ret }, _ => aiur_fn_490(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_6];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_6];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[507].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[507].bump_multiplicity(__i); } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => aiur_fn_507(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_6];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_6];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[508].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[508].bump_multiplicity(__i); } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => aiur_fn_508(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_3, __v_4, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_489] = [__v_6];
-        record.function_queries[489].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_494] = [__v_6];
+        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -43686,74 +43874,74 @@ fn aiur_fn_489(
   })
 }
 
-const INPUT_SIZE_490: usize = 4;
-const IN_490: usize = 4;
-const OUT_490: usize = 1;
-fn aiur_fn_490(
-  inp: [G; IN_490],
+const INPUT_SIZE_495: usize = 4;
+const IN_495: usize = 4;
+const OUT_495: usize = 1;
+fn aiur_fn_495(
+  inp: [G; IN_495],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_490], ExecError> {
+) -> Result<[G; OUT_495], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_1, __v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_1, __v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     let __v_6: G = G::from_u64(0);
     let __v_7: G = G::from_u64(0);
     let __v_8: G = { let __values: [G; 5] = [__v_6, __v_3, __v_5, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_10: G = { let __values: [G; 5] = [__v_9, __v_0, __v_1, __v_8, __v_5]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_2, __v_10, __v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_2, __v_10, __v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_490] = [__v_11];
-    record.function_queries[490].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_495] = [__v_11];
+    record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_491: usize = 4;
-const IN_491: usize = 4;
-const OUT_491: usize = 1;
-fn aiur_fn_491(
-  inp: [G; IN_491],
+const INPUT_SIZE_496: usize = 4;
+const IN_496: usize = 4;
+const OUT_496: usize = 1;
+fn aiur_fn_496(
+  inp: [G; IN_496],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_491], ExecError> {
+) -> Result<[G; OUT_496], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
     let __v_6: G = (__v_3 - __v_5);
     let __v_7: G = G::from_u64(0);
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_491] = [__v_8];
-    record.function_queries[491].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_496] = [__v_8];
+    record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_492: usize = 2;
-const IN_492: usize = 2;
-const OUT_492: usize = 2;
-fn aiur_fn_492(
-  inp: [G; IN_492],
+const INPUT_SIZE_497: usize = 2;
+const IN_497: usize = 2;
+const OUT_497: usize = 2;
+fn aiur_fn_497(
+  inp: [G; IN_497],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_492], ExecError> {
+) -> Result<[G; OUT_497], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43765,10 +43953,10 @@ fn aiur_fn_492(
     let __v_6: G = __loaded[4];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[429].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[429].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[429].bump_multiplicity(__i); } let __ret: [G; OUT_429] = unsafe { *(record.function_queries[429].output_at(__i).as_ptr() as *const [G; OUT_429]) }; __ret }, _ => aiur_fn_429(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[434].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[434].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[434].bump_multiplicity(__i); } let __ret: [G; OUT_434] = unsafe { *(record.function_queries[434].output_at(__i).as_ptr() as *const [G; OUT_434]) }; __ret }, _ => aiur_fn_434(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_492] = [__v_7, __v_4];
-        record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_497] = [__v_7, __v_4];
+        record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -43776,18 +43964,18 @@ fn aiur_fn_492(
           0u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_4 - __v_7);
-            let __ret: [G; OUT_492] = [__v_3, __v_8];
-            record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_497] = [__v_3, __v_8];
+            record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_492] = [__v_9, __v_10];
-            record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_497] = [__v_9, __v_10];
+            record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -43795,18 +43983,18 @@ fn aiur_fn_492(
       2u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_492] = [__v_3, __v_6];
-            record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_497] = [__v_3, __v_6];
+            record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_492] = [__v_9, __v_10];
-            record.function_queries[492].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_497] = [__v_9, __v_10];
+            record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -43818,41 +44006,41 @@ fn aiur_fn_492(
   })
 }
 
-const INPUT_SIZE_493: usize = 3;
-const IN_493: usize = 3;
-const OUT_493: usize = 1;
-fn aiur_fn_493(
-  inp: [G; IN_493],
+const INPUT_SIZE_498: usize = 3;
+const IN_498: usize = 3;
+const OUT_498: usize = 1;
+fn aiur_fn_498(
+  inp: [G; IN_498],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_493], ExecError> {
+) -> Result<[G; OUT_498], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = (__v_2 - __v_4);
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __ret: [G; OUT_493] = [__v_7];
-    record.function_queries[493].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_498] = [__v_7];
+    record.function_queries[498].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_494: usize = 2;
-const IN_494: usize = 2;
-const OUT_494: usize = 2;
-fn aiur_fn_494(
-  inp: [G; IN_494],
+const INPUT_SIZE_499: usize = 2;
+const IN_499: usize = 2;
+const OUT_499: usize = 2;
+fn aiur_fn_499(
+  inp: [G; IN_499],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_494], ExecError> {
+) -> Result<[G; OUT_499], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -43867,8 +44055,8 @@ fn aiur_fn_494(
         let __v_7: G = G::from_u64(0);
         let __v_8: G = G::from_u64(0);
         let __v_9: G = { let __values: [G; 4] = [__v_7, __v_1, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_494] = [__v_9, __v_4];
-        record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_499] = [__v_9, __v_4];
+        record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -43878,18 +44066,18 @@ fn aiur_fn_494(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_494] = [__v_10, __v_4];
-            record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_499] = [__v_10, __v_4];
+            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_494] = [__v_9, __v_10];
-            record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_499] = [__v_9, __v_10];
+            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -43898,20 +44086,20 @@ fn aiur_fn_494(
         match __v_1.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_494] = [__v_8, __v_6];
-            record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_499] = [__v_8, __v_6];
+            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_494] = [__v_9, __v_10];
-            record.function_queries[494].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_499] = [__v_9, __v_10];
+            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -43923,28 +44111,28 @@ fn aiur_fn_494(
   })
 }
 
-const INPUT_SIZE_495: usize = 4;
-const IN_495: usize = 4;
-const OUT_495: usize = 1;
-fn aiur_fn_495(
-  inp: [G; IN_495],
+const INPUT_SIZE_500: usize = 4;
+const IN_500: usize = 4;
+const OUT_500: usize = 1;
+fn aiur_fn_500(
+  inp: [G; IN_500],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_495], ExecError> {
+) -> Result<[G; OUT_500], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[0].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[0].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[0].bump_multiplicity(__i); } let __ret: [G; OUT_0] = unsafe { *(record.function_queries[0].output_at(__i).as_ptr() as *const [G; OUT_0]) }; __ret }, _ => aiur_fn_0(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_495] = [__v_0];
-        record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_500] = [__v_0];
+        record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -43959,95 +44147,95 @@ fn aiur_fn_495(
             let __v_10: G = __r_arr[0];
             match __v_10.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_495] = [__v_0];
-                record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_500] = [__v_0];
+                record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = (__v_7 - __v_3);
-                let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[494].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[494].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[494].bump_multiplicity(__i); } let __ret: [G; OUT_494] = unsafe { *(record.function_queries[494].output_at(__i).as_ptr() as *const [G; OUT_494]) }; __ret }, _ => aiur_fn_494(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = __r_arr[1];
                 let __v_14: G = (__v_2 - __v_13);
                 let __v_15: G = G::from_u64(0);
-                let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_12, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_12, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 let __v_17: G = G::from_u64(0);
-                let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
                 let __v_18: G = __r_arr[0];
-                let __ret: [G; OUT_495] = [__v_18];
-                record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_500] = [__v_18];
+                record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           3u64 => {
             let __v_10: G = G::from_u64(3);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__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_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_495] = [__v_14];
-            record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_500] = [__v_14];
+            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
             let __v_10: G = G::from_u64(4);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__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_3 + __v_12);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_8, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_8, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__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_11, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_495] = [__v_16];
-            record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_500] = [__v_16];
+            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           5u64 => {
             let __v_10: G = G::from_u64(5);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__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_3 + __v_12);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_8, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_8, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__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_11, __v_14, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_495] = [__v_16];
-            record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_500] = [__v_16];
+            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           6u64 => {
             let __v_10: G = G::from_u64(6);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(1);
             let __v_14: G = (__v_3 + __v_13);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_9, __v_1, __v_2, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_9, __v_1, __v_2, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_495] = [__v_16];
-            record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_500] = [__v_16];
+            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           8u64 => {
             let __v_10: G = G::from_u64(8);
-            let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = { let __values: [G; 4] = [__v_10, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_495] = [__v_12];
-            record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_500] = [__v_12];
+            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_495] = [__v_0];
-            record.function_queries[495].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_500] = [__v_0];
+            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44056,31 +44244,31 @@ fn aiur_fn_495(
   })
 }
 
-const INPUT_SIZE_496: usize = 4;
-const IN_496: usize = 4;
-const OUT_496: usize = 1;
-fn aiur_fn_496(
-  inp: [G; IN_496],
+const INPUT_SIZE_501: usize = 4;
+const IN_501: usize = 4;
+const OUT_501: usize = 1;
+fn aiur_fn_501(
+  inp: [G; IN_501],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_496], ExecError> {
+) -> Result<[G; OUT_501], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(1);
         let __v_6: G = G::from_u64(1);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_496] = [__v_8];
-        record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_501] = [__v_8];
+        record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -44091,35 +44279,35 @@ fn aiur_fn_496(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           3u64 => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_496] = [__v_10];
-                record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_501] = [__v_10];
+                record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__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_346] = { let __args: [G; IN_346] = [__v_0, __v_11, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_0, __v_11, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 match __v_12.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __ret: [G; OUT_496] = [__v_13];
-                    record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_501] = [__v_13];
+                    record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   0u64 => {
-                    let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[498].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[498].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[498].bump_multiplicity(__i); } let __ret: [G; OUT_498] = unsafe { *(record.function_queries[498].output_at(__i).as_ptr() as *const [G; OUT_498]) }; __ret }, _ => aiur_fn_498(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[503].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[503].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[503].bump_multiplicity(__i); } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => aiur_fn_503(__args, record, io_buffer, __cu)? } };
                     let __v_13: G = __r_arr[0];
-                    let __ret: [G; OUT_496] = [__v_13];
-                    record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_501] = [__v_13];
+                    record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -44130,10 +44318,10 @@ fn aiur_fn_496(
             }
           },
           _ => {
-            let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_496] = [__v_9];
-            record.function_queries[496].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_501] = [__v_9];
+            record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44142,15 +44330,15 @@ fn aiur_fn_496(
   })
 }
 
-const INPUT_SIZE_497: usize = 1;
-const IN_497: usize = 1;
-const OUT_497: usize = 1;
-fn aiur_fn_497(
-  inp: [G; IN_497],
+const INPUT_SIZE_502: usize = 1;
+const IN_502: usize = 1;
+const OUT_502: usize = 1;
+fn aiur_fn_502(
+  inp: [G; IN_502],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_497], ExecError> {
+) -> Result<[G; OUT_502], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
@@ -44162,33 +44350,33 @@ fn aiur_fn_497(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_497] = [__v_6];
-        record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_502] = [__v_6];
+        record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_497] = [__v_6];
-        record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_502] = [__v_6];
+        record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           0u64 => {
             let __v_7: G = G::from_u64(0);
-            let __ret: [G; OUT_497] = [__v_7];
-            record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_502] = [__v_7];
+            record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[502].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[502].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[502].bump_multiplicity(__i); } let __ret: [G; OUT_502] = unsafe { *(record.function_queries[502].output_at(__i).as_ptr() as *const [G; OUT_502]) }; __ret }, _ => aiur_fn_502(__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_497] = [__v_9];
-            record.function_queries[497].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_502] = [__v_9];
+            record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44200,53 +44388,53 @@ fn aiur_fn_497(
   })
 }
 
-const INPUT_SIZE_498: usize = 4;
-const IN_498: usize = 4;
-const OUT_498: usize = 1;
-fn aiur_fn_498(
-  inp: [G; IN_498],
+const INPUT_SIZE_503: usize = 4;
+const IN_503: usize = 4;
+const OUT_503: usize = 1;
+fn aiur_fn_503(
+  inp: [G; IN_503],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_498], ExecError> {
+) -> Result<[G; OUT_503], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = G::from_u64(0);
-    let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[354].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[354].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[354].bump_multiplicity(__i); } let __ret: [G; OUT_354] = unsafe { *(record.function_queries[354].output_at(__i).as_ptr() as *const [G; OUT_354]) }; __ret }, _ => aiur_fn_354(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[359].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[359].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[359].bump_multiplicity(__i); } let __ret: [G; OUT_359] = unsafe { *(record.function_queries[359].output_at(__i).as_ptr() as *const [G; OUT_359]) }; __ret }, _ => aiur_fn_359(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__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 = G::from_u64(0);
-    let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_0, __v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
     let __v_12: G = (__v_3 - __v_8);
-    let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_10, __v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_10, __v_6, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__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_358] = { let __args: [G; IN_358] = [__v_13, __v_8, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_13, __v_8, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
-    let __ret: [G; OUT_498] = [__v_15];
-    record.function_queries[498].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_503] = [__v_15];
+    record.function_queries[503].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_499: usize = 2;
-const IN_499: usize = 2;
-const OUT_499: usize = 3;
-fn aiur_fn_499(
-  inp: [G; IN_499],
+const INPUT_SIZE_504: usize = 2;
+const IN_504: usize = 2;
+const OUT_504: usize = 3;
+fn aiur_fn_504(
+  inp: [G; IN_504],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_499], ExecError> {
+) -> Result<[G; OUT_504], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44254,8 +44442,8 @@ fn aiur_fn_499(
       0u64 => {
         let __v_2: G = G::from_u64(0);
         let __v_3: G = G::from_u64(0);
-        let __ret: [G; OUT_499] = [__v_0, __v_2, __v_3];
-        record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_504] = [__v_0, __v_2, __v_3];
+        record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -44269,20 +44457,20 @@ fn aiur_fn_499(
           2u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__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 = G::from_u64(1);
             let __v_13: G = (__v_10 + __v_12);
-            let __ret: [G; OUT_499] = [__v_9, __v_13, __v_11];
-            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_504] = [__v_9, __v_13, __v_11];
+            record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_1 - __v_7);
-            let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[499].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[499].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[499].bump_multiplicity(__i); } let __ret: [G; OUT_499] = unsafe { *(record.function_queries[499].output_at(__i).as_ptr() as *const [G; OUT_499]) }; __ret }, _ => aiur_fn_499(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__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];
@@ -44290,15 +44478,15 @@ fn aiur_fn_499(
             let __v_13: G = (__v_10 + __v_12);
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_11 + __v_14);
-            let __ret: [G; OUT_499] = [__v_9, __v_13, __v_15];
-            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_504] = [__v_9, __v_13, __v_15];
+            record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_7: G = G::from_u64(0);
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_499] = [__v_0, __v_7, __v_8];
-            record.function_queries[499].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_504] = [__v_0, __v_7, __v_8];
+            record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44307,15 +44495,15 @@ fn aiur_fn_499(
   })
 }
 
-const INPUT_SIZE_500: usize = 4;
-const IN_500: usize = 4;
-const OUT_500: usize = 1;
-fn aiur_fn_500(
-  inp: [G; IN_500],
+const INPUT_SIZE_505: usize = 4;
+const IN_505: usize = 4;
+const OUT_505: usize = 1;
+fn aiur_fn_505(
+  inp: [G; IN_505],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_500], ExecError> {
+) -> Result<[G; OUT_505], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44328,22 +44516,22 @@ fn aiur_fn_500(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[497].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[497].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[497].bump_multiplicity(__i); } let __ret: [G; OUT_497] = unsafe { *(record.function_queries[497].output_at(__i).as_ptr() as *const [G; OUT_497]) }; __ret }, _ => aiur_fn_497(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
         let __v_10: G = (__v_3 - __v_9);
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __ret: [G; OUT_500] = [__v_12];
-        record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_505] = [__v_12];
+        record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 3] = [__v_11, __v_9, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -44354,20 +44542,20 @@ fn aiur_fn_500(
         let __v_17: G = { let __values: [G; 5] = [__v_13, __v_9, __v_15, __v_1, __v_16]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_18: G = G::from_u64(1);
         let __v_19: G = (__v_3 + __v_18);
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_17, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_6, __v_17, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
         let __v_21: G = G::from_u64(5);
         let __v_22: G = G::from_u64(0);
         let __v_23: G = { let __values: [G; 4] = [__v_21, __v_9, __v_20, __v_22]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_500] = [__v_23];
-        record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_505] = [__v_23];
+        record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
         let __v_11: G = G::from_u64(0);
         let __v_12: G = { let __values: [G; 3] = [__v_11, __v_9, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -44378,9 +44566,9 @@ fn aiur_fn_500(
         let __v_17: G = { let __values: [G; 5] = [__v_13, __v_9, __v_15, __v_1, __v_16]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_18: G = G::from_u64(1);
         let __v_19: G = (__v_3 + __v_18);
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_17, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_6, __v_17, __v_12, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_20, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_20, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_22: G = __loaded[0];
@@ -44390,12 +44578,12 @@ fn aiur_fn_500(
         match __v_22.as_canonical_u64() {
           1u64 => {
             let __v_26: G = G::from_u64(1);
-            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_10, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[337].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[337].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[337].bump_multiplicity(__i); } let __ret: [G; OUT_337] = unsafe { *(record.function_queries[337].output_at(__i).as_ptr() as *const [G; OUT_337]) }; __ret }, _ => aiur_fn_337(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
             let __v_28: G = G::from_u64(0);
             let __v_29: G = { let __values: [G; 4] = [__v_26, __v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_500] = [__v_29];
-            record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_505] = [__v_29];
+            record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -44405,13 +44593,13 @@ fn aiur_fn_500(
       },
       6u64 => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_5, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_11, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_11, __v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = G::from_u64(1);
         if (__v_12 != __v_13) {
@@ -44419,16 +44607,16 @@ fn aiur_fn_500(
         }
         let __v_14: G = G::from_u64(2);
         let __v_15: G = { let __values: [G; 5] = [__v_14, __v_9, __v_6, __v_1, __v_3]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_7, __v_15, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_7, __v_15, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_500] = [__v_16];
-        record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_505] = [__v_16];
+        record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -44437,9 +44625,9 @@ fn aiur_fn_500(
         let __v_13: G = __loaded[3];
         match __v_10.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[496].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[496].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[496].bump_multiplicity(__i); } let __ret: [G; OUT_496] = unsafe { *(record.function_queries[496].output_at(__i).as_ptr() as *const [G; OUT_496]) }; __ret }, _ => aiur_fn_496(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_14, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_14, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__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) {
@@ -44447,27 +44635,27 @@ fn aiur_fn_500(
             }
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(1);
-            let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_12, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_12, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
             match __v_19.as_canonical_u64() {
               0u64 => {
                 let __v_20: G = G::from_u64(1);
                 let __v_21: G = G::from_u64(1);
-                let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_12, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_12, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_500] = [__v_22];
-                record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_505] = [__v_22];
+                record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_20: G = G::from_u64(0);
-                let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_6, __v_1, __v_3, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_6, __v_1, __v_3, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
                 let __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(0);
-                let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_12, __v_21, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_12, __v_21, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_500] = [__v_23];
-                record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_505] = [__v_23];
+                record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -44479,27 +44667,27 @@ fn aiur_fn_500(
       },
       _ => {
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[495].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[495].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[495].bump_multiplicity(__i); } let __ret: [G; OUT_495] = unsafe { *(record.function_queries[495].output_at(__i).as_ptr() as *const [G; OUT_495]) }; __ret }, _ => aiur_fn_495(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_0, __v_1, __v_3, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[500].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[500].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[500].bump_multiplicity(__i); } let __ret: [G; OUT_500] = unsafe { *(record.function_queries[500].output_at(__i).as_ptr() as *const [G; OUT_500]) }; __ret }, _ => aiur_fn_500(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_9, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_500] = [__v_10];
-        record.function_queries[500].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_505] = [__v_10];
+        record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_501: usize = 4;
-const IN_501: usize = 4;
-const OUT_501: usize = 1;
-fn aiur_fn_501(
-  inp: [G; IN_501],
+const INPUT_SIZE_506: usize = 4;
+const IN_506: usize = 4;
+const OUT_506: usize = 1;
+fn aiur_fn_506(
+  inp: [G; IN_506],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_501], ExecError> {
+) -> Result<[G; OUT_506], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44511,20 +44699,20 @@ fn aiur_fn_501(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_501] = [__v_0];
-            record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_506] = [__v_0];
+            record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_501] = [__v_9];
-            record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_506] = [__v_9];
+            record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44537,7 +44725,7 @@ fn aiur_fn_501(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_11.as_canonical_u64() {
   0u64 => {
@@ -44545,24 +44733,24 @@ fn aiur_fn_501(
   },
   _ => {
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_8, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     break '__mc_0 [__v_13];
   },
 }
  };
             let __v_12: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_5, __v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_9, __v_6, __v_14, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[506].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => aiur_fn_506(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
-            let __ret: [G; OUT_501] = [__v_15];
-            record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_506] = [__v_15];
+            record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_11.as_canonical_u64() {
   0u64 => {
@@ -44570,14 +44758,14 @@ fn aiur_fn_501(
   },
   _ => {
     let __v_12: G = G::from_u64(0);
-    let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0, __v_2, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     break '__mc_1 [__v_13];
   },
 }
  };
             let __v_12: G = __mc_out___mc_1[0];
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_12, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_14: G = __loaded[0];
@@ -44586,16 +44774,16 @@ fn aiur_fn_501(
             let __v_17: G = __loaded[3];
             match __v_14.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_5, __v_15, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[501].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[501].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[501].bump_multiplicity(__i); } let __ret: [G; OUT_501] = unsafe { *(record.function_queries[501].output_at(__i).as_ptr() as *const [G; OUT_501]) }; __ret }, _ => aiur_fn_501(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_16, __v_6, __v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[506].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => aiur_fn_506(__args, record, io_buffer, __cu)? } };
                 let __v_23: G = __r_arr[0];
-                let __ret: [G; OUT_501] = [__v_23];
-                record.function_queries[501].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_506] = [__v_23];
+                record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -44612,43 +44800,43 @@ fn aiur_fn_501(
   })
 }
 
-const INPUT_SIZE_502: usize = 2;
-const IN_502: usize = 2;
-const OUT_502: usize = 1;
-fn aiur_fn_502(
-  inp: [G; IN_502],
+const INPUT_SIZE_507: usize = 2;
+const IN_507: usize = 2;
+const OUT_507: usize = 1;
+fn aiur_fn_507(
+  inp: [G; IN_507],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_502], ExecError> {
+) -> Result<[G; OUT_507], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_2: G = G::from_u64(2);
-        let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = []; let __cu = unconstrained; let __hit = record.function_queries[381].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[381].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[381].bump_multiplicity(__i); } let __ret: [G; OUT_381] = unsafe { *(record.function_queries[381].output_at(__i).as_ptr() as *const [G; OUT_381]) }; __ret }, _ => aiur_fn_381(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = []; let __cu = unconstrained; let __hit = record.function_queries[386].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[386].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[386].bump_multiplicity(__i); } let __ret: [G; OUT_386] = unsafe { *(record.function_queries[386].output_at(__i).as_ptr() as *const [G; OUT_386]) }; __ret }, _ => aiur_fn_386(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_502] = [__v_8];
-        record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_507] = [__v_8];
+        record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_2: G = G::from_u64(2);
-        let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = []; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_502] = [__v_8];
-        record.function_queries[502].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_507] = [__v_8];
+        record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -44658,23 +44846,23 @@ fn aiur_fn_502(
   })
 }
 
-const INPUT_SIZE_503: usize = 4;
-const IN_503: usize = 4;
-const OUT_503: usize = 1;
-fn aiur_fn_503(
-  inp: [G; IN_503],
+const INPUT_SIZE_508: usize = 4;
+const IN_508: usize = 4;
+const OUT_508: usize = 1;
+fn aiur_fn_508(
+  inp: [G; IN_508],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_503], ExecError> {
+) -> Result<[G; OUT_508], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_4, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
@@ -44686,10 +44874,10 @@ fn aiur_fn_503(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_503] = [__v_13];
-        record.function_queries[503].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_508] = [__v_13];
+        record.function_queries[508].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -44699,29 +44887,29 @@ fn aiur_fn_503(
   })
 }
 
-const INPUT_SIZE_504: usize = 3;
-const IN_504: usize = 3;
-const OUT_504: usize = 1;
-fn aiur_fn_504(
-  inp: [G; IN_504],
+const INPUT_SIZE_509: usize = 3;
+const IN_509: usize = 3;
+const OUT_509: usize = 1;
+fn aiur_fn_509(
+  inp: [G; IN_509],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_504], ExecError> {
+) -> Result<[G; OUT_509], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __ret: [G; OUT_504] = [__v_3];
-        record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_509] = [__v_3];
+        record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
@@ -44734,15 +44922,15 @@ fn aiur_fn_504(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_504] = { let __args: [G; IN_504] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[504].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[504].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[504].bump_multiplicity(__i); } let __ret: [G; OUT_504] = unsafe { *(record.function_queries[504].output_at(__i).as_ptr() as *const [G; OUT_504]) }; __ret }, _ => aiur_fn_504(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_6, __v_11, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_504] = [__v_12];
-            record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_509] = [__v_12];
+            record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_504] = [__v_3];
-            record.function_queries[504].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_509] = [__v_3];
+            record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44751,54 +44939,54 @@ fn aiur_fn_504(
   })
 }
 
-const INPUT_SIZE_505: usize = 3;
-const IN_505: usize = 3;
-const OUT_505: usize = 0;
-fn aiur_fn_505(
-  inp: [G; IN_505],
+const INPUT_SIZE_510: usize = 3;
+const IN_510: usize = 3;
+const OUT_510: usize = 0;
+fn aiur_fn_510(
+  inp: [G; IN_510],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_505], ExecError> {
+) -> Result<[G; OUT_510], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_505] = [];
-        record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_510] = [];
+        record.function_queries[510].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(0);
         let __v_5: G = G::from_u64(0);
         let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
         if (__v_7 != __v_8) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("projection on a Prop structure: field is not a Prop".to_string()) });
         }
-        let __ret: [G; OUT_505] = [];
-        record.function_queries[505].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_510] = [];
+        record.function_queries[510].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_506: usize = 4;
-const IN_506: usize = 4;
-const OUT_506: usize = 0;
-fn aiur_fn_506(
-  inp: [G; IN_506],
+const INPUT_SIZE_511: usize = 4;
+const IN_511: usize = 4;
+const OUT_511: usize = 0;
+fn aiur_fn_511(
+  inp: [G; IN_511],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_506], ExecError> {
+) -> Result<[G; OUT_511], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44806,33 +44994,33 @@ fn aiur_fn_506(
     let __v_3: G = inp[3];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_506] = [];
-        record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_511] = [];
+        record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = G::from_u64(0);
         let __v_6: G = G::from_u64(0);
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_506] = [];
-            record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_511] = [];
+            record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = G::from_u64(0);
             if (__v_9 != __v_10) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64(), msg: Some("projection on a Prop structure: later fields depend on a data field".to_string()) });
             }
-            let __ret: [G; OUT_506] = [];
-            record.function_queries[506].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_511] = [];
+            record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44841,15 +45029,15 @@ fn aiur_fn_506(
   })
 }
 
-const INPUT_SIZE_507: usize = 7;
-const IN_507: usize = 7;
-const OUT_507: usize = 1;
-fn aiur_fn_507(
-  inp: [G; IN_507],
+const INPUT_SIZE_512: usize = 7;
+const IN_512: usize = 7;
+const OUT_512: usize = 1;
+fn aiur_fn_512(
+  inp: [G; IN_512],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_507], ExecError> {
+) -> Result<[G; OUT_512], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -44868,24 +45056,24 @@ fn aiur_fn_507(
         let __v_11: G = (__v_1 - __v_2);
         match __v_11.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[505].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[505].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[505].bump_multiplicity(__i); } let __ret: [G; OUT_505] = unsafe { *(record.function_queries[505].output_at(__i).as_ptr() as *const [G; OUT_505]) }; __ret }, _ => aiur_fn_505(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_507] = [__v_8];
-            record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_5, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_512] = [__v_8];
+            record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[506].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[506].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[506].bump_multiplicity(__i); } let __ret: [G; OUT_506] = unsafe { *(record.function_queries[506].output_at(__i).as_ptr() as *const [G; OUT_506]) }; __ret }, _ => aiur_fn_506(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_5, __v_8, __v_9, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_14: G = G::from_u64(0);
-            let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_9, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_2 + __v_16);
-            let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[507].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[507].bump_multiplicity(__i); } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => aiur_fn_507(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_15, __v_1, __v_17, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_507] = [__v_18];
-            record.function_queries[507].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_512] = [__v_18];
+            record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -44897,25 +45085,25 @@ fn aiur_fn_507(
   })
 }
 
-const INPUT_SIZE_508: usize = 4;
-const IN_508: usize = 4;
-const OUT_508: usize = 1;
-fn aiur_fn_508(
-  inp: [G; IN_508],
+const INPUT_SIZE_513: usize = 4;
+const IN_513: usize = 4;
+const OUT_513: usize = 1;
+fn aiur_fn_513(
+  inp: [G; IN_513],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_508], ExecError> {
+) -> Result<[G; OUT_513], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -44928,7 +45116,7 @@ fn aiur_fn_508(
         if (__v_9 != __v_0) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_0.as_canonical_u64(), msg: Some("projection's structure type differs from the value's head".to_string()) });
         }
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_13: G = __loaded[0];
@@ -44950,7 +45138,7 @@ fn aiur_fn_508(
               return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_25.as_canonical_u64(), msg: Some("projection on an inductive with more than one constructor".to_string()) });
             }
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_28: G = __loaded[0];
@@ -44967,18 +45155,18 @@ fn aiur_fn_508(
             let __v_39: G = __loaded[11];
             match __v_28.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_30, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_30, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
                 let __v_40: G = __r_arr[0];
-                let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_40, __v_7, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[440].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[440].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[440].bump_multiplicity(__i); } let __ret: [G; OUT_440] = unsafe { *(record.function_queries[440].output_at(__i).as_ptr() as *const [G; OUT_440]) }; __ret }, _ => aiur_fn_440(__args, record, io_buffer, __cu)? } };
                 let __v_41: G = __r_arr[0];
                 let __v_42: G = (__v_16 + __v_17);
-                let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[503].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[503].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[503].bump_multiplicity(__i); } let __ret: [G; OUT_503] = unsafe { *(record.function_queries[503].output_at(__i).as_ptr() as *const [G; OUT_503]) }; __ret }, _ => aiur_fn_503(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_15, __v_10, __v_42, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[508].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[508].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[508].bump_multiplicity(__i); } let __ret: [G; OUT_508] = unsafe { *(record.function_queries[508].output_at(__i).as_ptr() as *const [G; OUT_508]) }; __ret }, _ => aiur_fn_508(__args, record, io_buffer, __cu)? } };
                 let __v_43: G = __r_arr[0];
                 let __v_44: G = G::from_u64(0);
-                let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[507].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[507].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[507].bump_multiplicity(__i); } let __ret: [G; OUT_507] = unsafe { *(record.function_queries[507].output_at(__i).as_ptr() as *const [G; OUT_507]) }; __ret }, _ => aiur_fn_507(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_41, __v_1, __v_44, __v_0, __v_2, __v_43, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } };
                 let __v_45: G = __r_arr[0];
-                let __ret: [G; OUT_508] = [__v_45];
-                record.function_queries[508].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_513] = [__v_45];
+                record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -44998,21 +45186,21 @@ fn aiur_fn_508(
   })
 }
 
-const INPUT_SIZE_509: usize = 2;
-const IN_509: usize = 2;
-const OUT_509: usize = 1;
-fn aiur_fn_509(
-  inp: [G; IN_509],
+const INPUT_SIZE_514: usize = 2;
+const IN_514: usize = 2;
+const OUT_514: usize = 1;
+fn aiur_fn_514(
+  inp: [G; IN_514],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_509], ExecError> {
+) -> Result<[G; OUT_514], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_2, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -45021,8 +45209,8 @@ fn aiur_fn_509(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_509] = [__v_5];
-        record.function_queries[509].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_514] = [__v_5];
+        record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -45032,483 +45220,483 @@ fn aiur_fn_509(
   })
 }
 
-const INPUT_SIZE_510: usize = 3;
-const IN_510: usize = 3;
-const OUT_510: usize = 0;
-fn aiur_fn_510(
-  inp: [G; IN_510],
+const INPUT_SIZE_515: usize = 3;
+const IN_515: usize = 3;
+const OUT_515: usize = 0;
+fn aiur_fn_515(
+  inp: [G; IN_515],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_510], ExecError> {
+) -> Result<[G; OUT_515], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = G::from_u64(1);
     if (__v_4 != __v_5) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("inferred type is not def-eq to the expected type".to_string()) });
     }
-    let __ret: [G; OUT_510] = [];
-    record.function_queries[510].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_515] = [];
+    record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_511: usize = 0;
-const IN_511: usize = 0;
-const OUT_511: usize = 1;
-fn aiur_fn_511(
-  inp: [G; IN_511],
+const INPUT_SIZE_516: usize = 0;
+const IN_516: usize = 0;
+const OUT_516: usize = 1;
+fn aiur_fn_516(
+  inp: [G; IN_516],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_511], ExecError> {
+) -> Result<[G; OUT_516], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(41);
-    let __v_1: G = G::from_u64(153);
-    let __v_2: G = G::from_u64(128);
-    let __v_3: G = G::from_u64(21);
-    let __v_4: G = G::from_u64(152);
-    let __v_5: G = G::from_u64(193);
-    let __v_6: G = G::from_u64(218);
-    let __v_7: G = G::from_u64(72);
-    let __v_8: G = G::from_u64(245);
-    let __v_9: G = G::from_u64(98);
-    let __v_10: G = G::from_u64(212);
-    let __v_11: G = G::from_u64(131);
-    let __v_12: G = G::from_u64(96);
-    let __v_13: G = G::from_u64(100);
-    let __v_14: G = G::from_u64(246);
-    let __v_15: G = G::from_u64(53);
-    let __v_16: G = G::from_u64(192);
-    let __v_17: G = G::from_u64(69);
-    let __v_18: G = G::from_u64(208);
-    let __v_19: G = G::from_u64(82);
-    let __v_20: G = G::from_u64(20);
-    let __v_21: G = G::from_u64(82);
-    let __v_22: G = G::from_u64(181);
-    let __v_23: G = G::from_u64(231);
-    let __v_24: G = G::from_u64(74);
-    let __v_25: G = G::from_u64(18);
-    let __v_26: G = G::from_u64(191);
-    let __v_27: G = G::from_u64(153);
-    let __v_28: G = G::from_u64(210);
-    let __v_29: G = G::from_u64(227);
-    let __v_30: G = G::from_u64(22);
-    let __v_31: G = G::from_u64(236);
+    let __v_0: G = G::from_u64(240);
+    let __v_1: G = G::from_u64(241);
+    let __v_2: G = G::from_u64(94);
+    let __v_3: G = G::from_u64(208);
+    let __v_4: G = G::from_u64(121);
+    let __v_5: G = G::from_u64(130);
+    let __v_6: G = G::from_u64(47);
+    let __v_7: G = G::from_u64(6);
+    let __v_8: G = G::from_u64(232);
+    let __v_9: G = G::from_u64(46);
+    let __v_10: G = G::from_u64(54);
+    let __v_11: G = G::from_u64(102);
+    let __v_12: G = G::from_u64(75);
+    let __v_13: G = G::from_u64(246);
+    let __v_14: G = G::from_u64(30);
+    let __v_15: G = G::from_u64(121);
+    let __v_16: G = G::from_u64(126);
+    let __v_17: G = G::from_u64(91);
+    let __v_18: G = G::from_u64(30);
+    let __v_19: G = G::from_u64(123);
+    let __v_20: G = G::from_u64(11);
+    let __v_21: G = G::from_u64(65);
+    let __v_22: G = G::from_u64(85);
+    let __v_23: G = G::from_u64(21);
+    let __v_24: G = G::from_u64(39);
+    let __v_25: G = G::from_u64(98);
+    let __v_26: G = G::from_u64(197);
+    let __v_27: G = G::from_u64(19);
+    let __v_28: G = G::from_u64(39);
+    let __v_29: G = G::from_u64(75);
+    let __v_30: G = G::from_u64(254);
+    let __v_31: G = G::from_u64(225);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_511] = [__v_32];
-    record.function_queries[511].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_516] = [__v_32];
+    record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_512: usize = 0;
-const IN_512: usize = 0;
-const OUT_512: usize = 1;
-fn aiur_fn_512(
-  inp: [G; IN_512],
+const INPUT_SIZE_517: usize = 0;
+const IN_517: usize = 0;
+const OUT_517: usize = 1;
+fn aiur_fn_517(
+  inp: [G; IN_517],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_512], ExecError> {
+) -> Result<[G; OUT_517], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(27);
-    let __v_1: G = G::from_u64(172);
-    let __v_2: G = G::from_u64(4);
-    let __v_3: G = G::from_u64(23);
-    let __v_4: G = G::from_u64(86);
-    let __v_5: G = G::from_u64(237);
-    let __v_6: G = G::from_u64(34);
-    let __v_7: G = G::from_u64(215);
-    let __v_8: G = G::from_u64(59);
-    let __v_9: G = G::from_u64(188);
-    let __v_10: G = G::from_u64(172);
-    let __v_11: G = G::from_u64(132);
-    let __v_12: G = G::from_u64(154);
-    let __v_13: G = G::from_u64(148);
-    let __v_14: G = G::from_u64(242);
-    let __v_15: G = G::from_u64(70);
-    let __v_16: G = G::from_u64(238);
-    let __v_17: G = G::from_u64(38);
-    let __v_18: G = G::from_u64(150);
-    let __v_19: G = G::from_u64(153);
-    let __v_20: G = G::from_u64(159);
-    let __v_21: G = G::from_u64(175);
-    let __v_22: G = G::from_u64(53);
-    let __v_23: G = G::from_u64(25);
-    let __v_24: G = G::from_u64(64);
-    let __v_25: G = G::from_u64(70);
-    let __v_26: G = G::from_u64(141);
-    let __v_27: G = G::from_u64(150);
-    let __v_28: G = G::from_u64(41);
-    let __v_29: G = G::from_u64(112);
-    let __v_30: G = G::from_u64(202);
-    let __v_31: G = G::from_u64(42);
+    let __v_0: G = G::from_u64(138);
+    let __v_1: G = G::from_u64(93);
+    let __v_2: G = G::from_u64(94);
+    let __v_3: G = G::from_u64(238);
+    let __v_4: G = G::from_u64(65);
+    let __v_5: G = G::from_u64(74);
+    let __v_6: G = G::from_u64(47);
+    let __v_7: G = G::from_u64(165);
+    let __v_8: G = G::from_u64(149);
+    let __v_9: G = G::from_u64(107);
+    let __v_10: G = G::from_u64(116);
+    let __v_11: G = G::from_u64(232);
+    let __v_12: G = G::from_u64(50);
+    let __v_13: G = G::from_u64(58);
+    let __v_14: G = G::from_u64(32);
+    let __v_15: G = G::from_u64(80);
+    let __v_16: G = G::from_u64(141);
+    let __v_17: G = G::from_u64(119);
+    let __v_18: G = G::from_u64(78);
+    let __v_19: G = G::from_u64(209);
+    let __v_20: G = G::from_u64(181);
+    let __v_21: G = G::from_u64(96);
+    let __v_22: G = G::from_u64(63);
+    let __v_23: G = G::from_u64(85);
+    let __v_24: G = G::from_u64(231);
+    let __v_25: G = G::from_u64(116);
+    let __v_26: G = G::from_u64(173);
+    let __v_27: G = G::from_u64(137);
+    let __v_28: G = G::from_u64(107);
+    let __v_29: G = G::from_u64(211);
+    let __v_30: G = G::from_u64(230);
+    let __v_31: G = G::from_u64(231);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_512] = [__v_32];
-    record.function_queries[512].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_517] = [__v_32];
+    record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_513: usize = 0;
-const IN_513: usize = 0;
-const OUT_513: usize = 1;
-fn aiur_fn_513(
-  inp: [G; IN_513],
+const INPUT_SIZE_518: usize = 0;
+const IN_518: usize = 0;
+const OUT_518: usize = 1;
+fn aiur_fn_518(
+  inp: [G; IN_518],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_513], ExecError> {
+) -> Result<[G; OUT_518], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(18);
-    let __v_1: G = G::from_u64(243);
-    let __v_2: G = G::from_u64(134);
-    let __v_3: G = G::from_u64(244);
-    let __v_4: G = G::from_u64(134);
-    let __v_5: G = G::from_u64(145);
-    let __v_6: G = G::from_u64(59);
-    let __v_7: G = G::from_u64(17);
-    let __v_8: G = G::from_u64(181);
-    let __v_9: G = G::from_u64(71);
-    let __v_10: G = G::from_u64(60);
-    let __v_11: G = G::from_u64(178);
-    let __v_12: G = G::from_u64(83);
-    let __v_13: G = G::from_u64(131);
-    let __v_14: G = G::from_u64(48);
-    let __v_15: G = G::from_u64(213);
-    let __v_16: G = G::from_u64(31);
-    let __v_17: G = G::from_u64(37);
-    let __v_18: G = G::from_u64(174);
-    let __v_19: G = G::from_u64(236);
-    let __v_20: G = G::from_u64(127);
-    let __v_21: G = G::from_u64(45);
-    let __v_22: G = G::from_u64(125);
-    let __v_23: G = G::from_u64(107);
-    let __v_24: G = G::from_u64(150);
-    let __v_25: G = G::from_u64(144);
-    let __v_26: G = G::from_u64(67);
-    let __v_27: G = G::from_u64(41);
-    let __v_28: G = G::from_u64(199);
-    let __v_29: G = G::from_u64(139);
-    let __v_30: G = G::from_u64(105);
-    let __v_31: G = G::from_u64(103);
+    let __v_0: G = G::from_u64(124);
+    let __v_1: G = G::from_u64(73);
+    let __v_2: G = G::from_u64(119);
+    let __v_3: G = G::from_u64(25);
+    let __v_4: G = G::from_u64(110);
+    let __v_5: G = G::from_u64(149);
+    let __v_6: G = G::from_u64(190);
+    let __v_7: G = G::from_u64(42);
+    let __v_8: G = G::from_u64(117);
+    let __v_9: G = G::from_u64(159);
+    let __v_10: G = G::from_u64(201);
+    let __v_11: G = G::from_u64(198);
+    let __v_12: G = G::from_u64(209);
+    let __v_13: G = G::from_u64(83);
+    let __v_14: G = G::from_u64(61);
+    let __v_15: G = G::from_u64(184);
+    let __v_16: G = G::from_u64(218);
+    let __v_17: G = G::from_u64(73);
+    let __v_18: G = G::from_u64(89);
+    let __v_19: G = G::from_u64(47);
+    let __v_20: G = G::from_u64(6);
+    let __v_21: G = G::from_u64(65);
+    let __v_22: G = G::from_u64(155);
+    let __v_23: G = G::from_u64(21);
+    let __v_24: G = G::from_u64(93);
+    let __v_25: G = G::from_u64(136);
+    let __v_26: G = G::from_u64(131);
+    let __v_27: G = G::from_u64(51);
+    let __v_28: G = G::from_u64(200);
+    let __v_29: G = G::from_u64(221);
+    let __v_30: G = G::from_u64(137);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_513] = [__v_32];
-    record.function_queries[513].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_518] = [__v_32];
+    record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_514: usize = 0;
-const IN_514: usize = 0;
-const OUT_514: usize = 1;
-fn aiur_fn_514(
-  inp: [G; IN_514],
+const INPUT_SIZE_519: usize = 0;
+const IN_519: usize = 0;
+const OUT_519: usize = 1;
+fn aiur_fn_519(
+  inp: [G; IN_519],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_514], ExecError> {
+) -> Result<[G; OUT_519], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(123);
-    let __v_1: G = G::from_u64(63);
-    let __v_2: G = G::from_u64(106);
-    let __v_3: G = G::from_u64(110);
-    let __v_4: G = G::from_u64(235);
-    let __v_5: G = G::from_u64(243);
-    let __v_6: G = G::from_u64(42);
-    let __v_7: G = G::from_u64(157);
-    let __v_8: G = G::from_u64(90);
-    let __v_9: G = G::from_u64(84);
-    let __v_10: G = G::from_u64(48);
-    let __v_11: G = G::from_u64(94);
-    let __v_12: G = G::from_u64(105);
-    let __v_13: G = G::from_u64(61);
-    let __v_14: G = G::from_u64(206);
-    let __v_15: G = G::from_u64(96);
-    let __v_16: G = G::from_u64(81);
-    let __v_17: G = G::from_u64(26);
-    let __v_18: G = G::from_u64(254);
-    let __v_19: G = G::from_u64(177);
-    let __v_20: G = G::from_u64(250);
-    let __v_21: G = G::from_u64(17);
-    let __v_22: G = G::from_u64(188);
-    let __v_23: G = G::from_u64(136);
-    let __v_24: G = G::from_u64(68);
-    let __v_25: G = G::from_u64(165);
-    let __v_26: G = G::from_u64(194);
-    let __v_27: G = G::from_u64(27);
-    let __v_28: G = G::from_u64(191);
-    let __v_29: G = G::from_u64(211);
-    let __v_30: G = G::from_u64(33);
-    let __v_31: G = G::from_u64(76);
+    let __v_0: G = G::from_u64(54);
+    let __v_1: G = G::from_u64(61);
+    let __v_2: G = G::from_u64(7);
+    let __v_3: G = G::from_u64(17);
+    let __v_4: G = G::from_u64(130);
+    let __v_5: G = G::from_u64(190);
+    let __v_6: G = G::from_u64(65);
+    let __v_7: G = G::from_u64(78);
+    let __v_8: G = G::from_u64(26);
+    let __v_9: G = G::from_u64(88);
+    let __v_10: G = G::from_u64(89);
+    let __v_11: G = G::from_u64(155);
+    let __v_12: G = G::from_u64(131);
+    let __v_13: G = G::from_u64(245);
+    let __v_14: G = G::from_u64(225);
+    let __v_15: G = G::from_u64(159);
+    let __v_16: G = G::from_u64(155);
+    let __v_17: G = G::from_u64(135);
+    let __v_18: G = G::from_u64(55);
+    let __v_19: G = G::from_u64(35);
+    let __v_20: G = G::from_u64(5);
+    let __v_21: G = G::from_u64(79);
+    let __v_22: G = G::from_u64(66);
+    let __v_23: G = G::from_u64(135);
+    let __v_24: G = G::from_u64(186);
+    let __v_25: G = G::from_u64(105);
+    let __v_26: G = G::from_u64(112);
+    let __v_27: G = G::from_u64(90);
+    let __v_28: G = G::from_u64(175);
+    let __v_29: G = G::from_u64(239);
+    let __v_30: G = G::from_u64(39);
+    let __v_31: G = G::from_u64(218);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_514] = [__v_32];
-    record.function_queries[514].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_519] = [__v_32];
+    record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_515: usize = 0;
-const IN_515: usize = 0;
-const OUT_515: usize = 1;
-fn aiur_fn_515(
-  inp: [G; IN_515],
+const INPUT_SIZE_520: usize = 0;
+const IN_520: usize = 0;
+const OUT_520: usize = 1;
+fn aiur_fn_520(
+  inp: [G; IN_520],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_515], ExecError> {
+) -> Result<[G; OUT_520], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(171);
-    let __v_1: G = G::from_u64(20);
-    let __v_2: G = G::from_u64(112);
-    let __v_3: G = G::from_u64(25);
-    let __v_4: G = G::from_u64(100);
-    let __v_5: G = G::from_u64(25);
-    let __v_6: G = G::from_u64(247);
-    let __v_7: G = G::from_u64(29);
-    let __v_8: G = G::from_u64(6);
-    let __v_9: G = G::from_u64(254);
-    let __v_10: G = G::from_u64(237);
-    let __v_11: G = G::from_u64(156);
-    let __v_12: G = G::from_u64(203);
-    let __v_13: G = G::from_u64(140);
-    let __v_14: G = G::from_u64(29);
-    let __v_15: G = G::from_u64(3);
-    let __v_16: G = G::from_u64(103);
-    let __v_17: G = G::from_u64(69);
-    let __v_18: G = G::from_u64(40);
-    let __v_19: G = G::from_u64(236);
-    let __v_20: G = G::from_u64(3);
-    let __v_21: G = G::from_u64(1);
-    let __v_22: G = G::from_u64(43);
-    let __v_23: G = G::from_u64(9);
-    let __v_24: G = G::from_u64(91);
-    let __v_25: G = G::from_u64(173);
-    let __v_26: G = G::from_u64(193);
-    let __v_27: G = G::from_u64(105);
-    let __v_28: G = G::from_u64(212);
-    let __v_29: G = G::from_u64(141);
-    let __v_30: G = G::from_u64(3);
-    let __v_31: G = G::from_u64(208);
+    let __v_0: G = G::from_u64(140);
+    let __v_1: G = G::from_u64(192);
+    let __v_2: G = G::from_u64(225);
+    let __v_3: G = G::from_u64(54);
+    let __v_4: G = G::from_u64(12);
+    let __v_5: G = G::from_u64(27);
+    let __v_6: G = G::from_u64(41);
+    let __v_7: G = G::from_u64(16);
+    let __v_8: G = G::from_u64(141);
+    let __v_9: G = G::from_u64(171);
+    let __v_10: G = G::from_u64(61);
+    let __v_11: G = G::from_u64(97);
+    let __v_12: G = G::from_u64(114);
+    let __v_13: G = G::from_u64(231);
+    let __v_14: G = G::from_u64(252);
+    let __v_15: G = G::from_u64(232);
+    let __v_16: G = G::from_u64(169);
+    let __v_17: G = G::from_u64(170);
+    let __v_18: G = G::from_u64(150);
+    let __v_19: G = G::from_u64(64);
+    let __v_20: G = G::from_u64(218);
+    let __v_21: G = G::from_u64(164);
+    let __v_22: G = G::from_u64(187);
+    let __v_23: G = G::from_u64(233);
+    let __v_24: G = G::from_u64(155);
+    let __v_25: G = G::from_u64(161);
+    let __v_26: G = G::from_u64(48);
+    let __v_27: G = G::from_u64(93);
+    let __v_28: G = G::from_u64(150);
+    let __v_29: G = G::from_u64(35);
+    let __v_30: G = G::from_u64(98);
+    let __v_31: G = G::from_u64(75);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_515] = [__v_32];
-    record.function_queries[515].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_520] = [__v_32];
+    record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_516: usize = 0;
-const IN_516: usize = 0;
-const OUT_516: usize = 1;
-fn aiur_fn_516(
-  inp: [G; IN_516],
+const INPUT_SIZE_521: usize = 0;
+const IN_521: usize = 0;
+const OUT_521: usize = 1;
+fn aiur_fn_521(
+  inp: [G; IN_521],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_516], ExecError> {
+) -> Result<[G; OUT_521], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(35);
-    let __v_1: G = G::from_u64(190);
-    let __v_2: G = G::from_u64(163);
-    let __v_3: G = G::from_u64(187);
-    let __v_4: G = G::from_u64(243);
-    let __v_5: G = G::from_u64(168);
-    let __v_6: G = G::from_u64(208);
-    let __v_7: G = G::from_u64(168);
-    let __v_8: G = G::from_u64(208);
-    let __v_9: G = G::from_u64(3);
-    let __v_10: G = G::from_u64(60);
-    let __v_11: G = G::from_u64(247);
-    let __v_12: G = G::from_u64(229);
-    let __v_13: G = G::from_u64(106);
-    let __v_14: G = G::from_u64(240);
-    let __v_15: G = G::from_u64(196);
-    let __v_16: G = G::from_u64(174);
-    let __v_17: G = G::from_u64(224);
-    let __v_18: G = G::from_u64(21);
-    let __v_19: G = G::from_u64(130);
-    let __v_20: G = G::from_u64(213);
-    let __v_21: G = G::from_u64(167);
-    let __v_22: G = G::from_u64(88);
-    let __v_23: G = G::from_u64(192);
-    let __v_24: G = G::from_u64(223);
-    let __v_25: G = G::from_u64(86);
-    let __v_26: G = G::from_u64(21);
-    let __v_27: G = G::from_u64(146);
-    let __v_28: G = G::from_u64(156);
-    let __v_29: G = G::from_u64(166);
-    let __v_30: G = G::from_u64(32);
-    let __v_31: G = G::from_u64(77);
+    let __v_0: G = G::from_u64(173);
+    let __v_1: G = G::from_u64(37);
+    let __v_2: G = G::from_u64(191);
+    let __v_3: G = G::from_u64(210);
+    let __v_4: G = G::from_u64(7);
+    let __v_5: G = G::from_u64(186);
+    let __v_6: G = G::from_u64(232);
+    let __v_7: G = G::from_u64(50);
+    let __v_8: G = G::from_u64(199);
+    let __v_9: G = G::from_u64(61);
+    let __v_10: G = G::from_u64(92);
+    let __v_11: G = G::from_u64(230);
+    let __v_12: G = G::from_u64(20);
+    let __v_13: G = G::from_u64(190);
+    let __v_14: G = G::from_u64(173);
+    let __v_15: G = G::from_u64(34);
+    let __v_16: G = G::from_u64(239);
+    let __v_17: G = G::from_u64(152);
+    let __v_18: G = G::from_u64(98);
+    let __v_19: G = G::from_u64(225);
+    let __v_20: G = G::from_u64(16);
+    let __v_21: G = G::from_u64(248);
+    let __v_22: G = G::from_u64(209);
+    let __v_23: G = G::from_u64(122);
+    let __v_24: G = G::from_u64(80);
+    let __v_25: G = G::from_u64(100);
+    let __v_26: G = G::from_u64(255);
+    let __v_27: G = G::from_u64(183);
+    let __v_28: G = G::from_u64(96);
+    let __v_29: G = G::from_u64(62);
+    let __v_30: G = G::from_u64(238);
+    let __v_31: G = G::from_u64(61);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_516] = [__v_32];
-    record.function_queries[516].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_521] = [__v_32];
+    record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_517: usize = 0;
-const IN_517: usize = 0;
-const OUT_517: usize = 1;
-fn aiur_fn_517(
-  inp: [G; IN_517],
+const INPUT_SIZE_522: usize = 0;
+const IN_522: usize = 0;
+const OUT_522: usize = 1;
+fn aiur_fn_522(
+  inp: [G; IN_522],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_517], ExecError> {
+) -> Result<[G; OUT_522], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(190);
-    let __v_1: G = G::from_u64(80);
-    let __v_2: G = G::from_u64(182);
-    let __v_3: G = G::from_u64(5);
-    let __v_4: G = G::from_u64(61);
-    let __v_5: G = G::from_u64(240);
-    let __v_6: G = G::from_u64(176);
-    let __v_7: G = G::from_u64(116);
-    let __v_8: G = G::from_u64(56);
-    let __v_9: G = G::from_u64(164);
-    let __v_10: G = G::from_u64(172);
-    let __v_11: G = G::from_u64(46);
-    let __v_12: G = G::from_u64(239);
-    let __v_13: G = G::from_u64(215);
-    let __v_14: G = G::from_u64(10);
-    let __v_15: G = G::from_u64(17);
-    let __v_16: G = G::from_u64(112);
-    let __v_17: G = G::from_u64(139);
-    let __v_18: G = G::from_u64(12);
-    let __v_19: G = G::from_u64(187);
-    let __v_20: G = G::from_u64(15);
-    let __v_21: G = G::from_u64(201);
-    let __v_22: G = G::from_u64(5);
-    let __v_23: G = G::from_u64(100);
-    let __v_24: G = G::from_u64(186);
-    let __v_25: G = G::from_u64(254);
-    let __v_26: G = G::from_u64(230);
-    let __v_27: G = G::from_u64(225);
-    let __v_28: G = G::from_u64(101);
-    let __v_29: G = G::from_u64(97);
-    let __v_30: G = G::from_u64(93);
-    let __v_31: G = G::from_u64(232);
+    let __v_0: G = G::from_u64(227);
+    let __v_1: G = G::from_u64(101);
+    let __v_2: G = G::from_u64(143);
+    let __v_3: G = G::from_u64(80);
+    let __v_4: G = G::from_u64(220);
+    let __v_5: G = G::from_u64(81);
+    let __v_6: G = G::from_u64(35);
+    let __v_7: G = G::from_u64(239);
+    let __v_8: G = G::from_u64(255);
+    let __v_9: G = G::from_u64(33);
+    let __v_10: G = G::from_u64(53);
+    let __v_11: G = G::from_u64(136);
+    let __v_12: G = G::from_u64(222);
+    let __v_13: G = G::from_u64(227);
+    let __v_14: G = G::from_u64(212);
+    let __v_15: G = G::from_u64(198);
+    let __v_16: G = G::from_u64(6);
+    let __v_17: G = G::from_u64(63);
+    let __v_18: G = G::from_u64(94);
+    let __v_19: G = G::from_u64(219);
+    let __v_20: G = G::from_u64(24);
+    let __v_21: G = G::from_u64(149);
+    let __v_22: G = G::from_u64(8);
+    let __v_23: G = G::from_u64(80);
+    let __v_24: G = G::from_u64(172);
+    let __v_25: G = G::from_u64(4);
+    let __v_26: G = G::from_u64(144);
+    let __v_27: G = G::from_u64(201);
+    let __v_28: G = G::from_u64(55);
+    let __v_29: G = G::from_u64(129);
+    let __v_30: G = G::from_u64(144);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_517] = [__v_32];
-    record.function_queries[517].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_522] = [__v_32];
+    record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_518: usize = 0;
-const IN_518: usize = 0;
-const OUT_518: usize = 1;
-fn aiur_fn_518(
-  inp: [G; IN_518],
+const INPUT_SIZE_523: usize = 0;
+const IN_523: usize = 0;
+const OUT_523: usize = 1;
+fn aiur_fn_523(
+  inp: [G; IN_523],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_518], ExecError> {
+) -> Result<[G; OUT_523], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(196);
-    let __v_1: G = G::from_u64(137);
-    let __v_2: G = G::from_u64(50);
-    let __v_3: G = G::from_u64(145);
-    let __v_4: G = G::from_u64(151);
-    let __v_5: G = G::from_u64(181);
-    let __v_6: G = G::from_u64(154);
-    let __v_7: G = G::from_u64(4);
-    let __v_8: G = G::from_u64(13);
-    let __v_9: G = G::from_u64(30);
-    let __v_10: G = G::from_u64(94);
-    let __v_11: G = G::from_u64(77);
-    let __v_12: G = G::from_u64(93);
-    let __v_13: G = G::from_u64(230);
-    let __v_14: G = G::from_u64(167);
-    let __v_15: G = G::from_u64(112);
-    let __v_16: G = G::from_u64(71);
-    let __v_17: G = G::from_u64(141);
-    let __v_18: G = G::from_u64(30);
-    let __v_19: G = G::from_u64(164);
-    let __v_20: G = G::from_u64(249);
-    let __v_21: G = G::from_u64(117);
-    let __v_22: G = G::from_u64(1);
-    let __v_23: G = G::from_u64(118);
-    let __v_24: G = G::from_u64(2);
-    let __v_25: G = G::from_u64(109);
-    let __v_26: G = G::from_u64(210);
-    let __v_27: G = G::from_u64(191);
-    let __v_28: G = G::from_u64(133);
-    let __v_29: G = G::from_u64(147);
-    let __v_30: G = G::from_u64(191);
-    let __v_31: G = G::from_u64(34);
+    let __v_0: G = G::from_u64(156);
+    let __v_1: G = G::from_u64(145);
+    let __v_2: G = G::from_u64(231);
+    let __v_3: G = G::from_u64(157);
+    let __v_4: G = G::from_u64(231);
+    let __v_5: G = G::from_u64(50);
+    let __v_6: G = G::from_u64(34);
+    let __v_7: G = G::from_u64(107);
+    let __v_8: G = G::from_u64(162);
+    let __v_9: G = G::from_u64(231);
+    let __v_10: G = G::from_u64(60);
+    let __v_11: G = G::from_u64(189);
+    let __v_12: G = G::from_u64(211);
+    let __v_13: G = G::from_u64(48);
+    let __v_14: G = G::from_u64(133);
+    let __v_15: G = G::from_u64(27);
+    let __v_16: G = G::from_u64(174);
+    let __v_17: G = G::from_u64(196);
+    let __v_18: G = G::from_u64(6);
+    let __v_19: G = G::from_u64(104);
+    let __v_20: G = G::from_u64(235);
+    let __v_21: G = G::from_u64(64);
+    let __v_22: G = G::from_u64(198);
+    let __v_23: G = G::from_u64(243);
+    let __v_24: G = G::from_u64(42);
+    let __v_25: G = G::from_u64(162);
+    let __v_26: G = G::from_u64(248);
+    let __v_27: G = G::from_u64(218);
+    let __v_28: G = G::from_u64(197);
+    let __v_29: G = G::from_u64(160);
+    let __v_30: G = G::from_u64(75);
+    let __v_31: G = G::from_u64(81);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_518] = [__v_32];
-    record.function_queries[518].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_523] = [__v_32];
+    record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_519: usize = 0;
-const IN_519: usize = 0;
-const OUT_519: usize = 1;
-fn aiur_fn_519(
-  inp: [G; IN_519],
+const INPUT_SIZE_524: usize = 0;
+const IN_524: usize = 0;
+const OUT_524: usize = 1;
+fn aiur_fn_524(
+  inp: [G; IN_524],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_519], ExecError> {
+) -> Result<[G; OUT_524], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(14);
-    let __v_1: G = G::from_u64(181);
-    let __v_2: G = G::from_u64(185);
-    let __v_3: G = G::from_u64(135);
-    let __v_4: G = G::from_u64(241);
-    let __v_5: G = G::from_u64(33);
-    let __v_6: G = G::from_u64(36);
-    let __v_7: G = G::from_u64(190);
-    let __v_8: G = G::from_u64(5);
-    let __v_9: G = G::from_u64(117);
-    let __v_10: G = G::from_u64(164);
-    let __v_11: G = G::from_u64(119);
-    let __v_12: G = G::from_u64(204);
-    let __v_13: G = G::from_u64(10);
-    let __v_14: G = G::from_u64(83);
-    let __v_15: G = G::from_u64(85);
-    let __v_16: G = G::from_u64(22);
-    let __v_17: G = G::from_u64(162);
-    let __v_18: G = G::from_u64(75);
-    let __v_19: G = G::from_u64(10);
-    let __v_20: G = G::from_u64(229);
-    let __v_21: G = G::from_u64(206);
-    let __v_22: G = G::from_u64(221);
-    let __v_23: G = G::from_u64(190);
-    let __v_24: G = G::from_u64(226);
-    let __v_25: G = G::from_u64(212);
-    let __v_26: G = G::from_u64(114);
-    let __v_27: G = G::from_u64(118);
-    let __v_28: G = G::from_u64(90);
-    let __v_29: G = G::from_u64(237);
-    let __v_30: G = G::from_u64(41);
-    let __v_31: G = G::from_u64(156);
+    let __v_0: G = G::from_u64(160);
+    let __v_1: G = G::from_u64(125);
+    let __v_2: G = G::from_u64(181);
+    let __v_3: G = G::from_u64(50);
+    let __v_4: G = G::from_u64(116);
+    let __v_5: G = G::from_u64(126);
+    let __v_6: G = G::from_u64(101);
+    let __v_7: G = G::from_u64(238);
+    let __v_8: G = G::from_u64(119);
+    let __v_9: G = G::from_u64(167);
+    let __v_10: G = G::from_u64(186);
+    let __v_11: G = G::from_u64(1);
+    let __v_12: G = G::from_u64(80);
+    let __v_13: G = G::from_u64(105);
+    let __v_14: G = G::from_u64(189);
+    let __v_15: G = G::from_u64(186);
+    let __v_16: G = G::from_u64(241);
+    let __v_17: G = G::from_u64(247);
+    let __v_18: G = G::from_u64(9);
+    let __v_19: G = G::from_u64(206);
+    let __v_20: G = G::from_u64(13);
+    let __v_21: G = G::from_u64(96);
+    let __v_22: G = G::from_u64(184);
+    let __v_23: G = G::from_u64(60);
+    let __v_24: G = G::from_u64(148);
+    let __v_25: G = G::from_u64(244);
+    let __v_26: G = G::from_u64(13);
+    let __v_27: G = G::from_u64(14);
+    let __v_28: G = G::from_u64(94);
+    let __v_29: G = G::from_u64(87);
+    let __v_30: G = G::from_u64(89);
+    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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_519] = [__v_32];
-    record.function_queries[519].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_524] = [__v_32];
+    record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_520: usize = 0;
-const IN_520: usize = 0;
-const OUT_520: usize = 1;
-fn aiur_fn_520(
-  inp: [G; IN_520],
+const INPUT_SIZE_525: usize = 0;
+const IN_525: usize = 0;
+const OUT_525: usize = 1;
+fn aiur_fn_525(
+  inp: [G; IN_525],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_520], ExecError> {
+) -> Result<[G; OUT_525], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(230);
     let __v_1: G = G::from_u64(235);
@@ -45543,294 +45731,294 @@ fn aiur_fn_520(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_520] = [__v_32];
-    record.function_queries[520].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_525] = [__v_32];
+    record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_521: usize = 0;
-const IN_521: usize = 0;
-const OUT_521: usize = 1;
-fn aiur_fn_521(
-  inp: [G; IN_521],
+const INPUT_SIZE_526: usize = 0;
+const IN_526: usize = 0;
+const OUT_526: usize = 1;
+fn aiur_fn_526(
+  inp: [G; IN_526],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_521], ExecError> {
+) -> Result<[G; OUT_526], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(227);
-    let __v_1: G = G::from_u64(8);
-    let __v_2: G = G::from_u64(3);
-    let __v_3: G = G::from_u64(91);
-    let __v_4: G = G::from_u64(223);
-    let __v_5: G = G::from_u64(40);
-    let __v_6: G = G::from_u64(12);
-    let __v_7: G = G::from_u64(146);
-    let __v_8: G = G::from_u64(117);
-    let __v_9: G = G::from_u64(86);
-    let __v_10: G = G::from_u64(130);
-    let __v_11: G = G::from_u64(77);
-    let __v_12: G = G::from_u64(106);
-    let __v_13: G = G::from_u64(159);
-    let __v_14: G = G::from_u64(146);
-    let __v_15: G = G::from_u64(54);
-    let __v_16: G = G::from_u64(161);
-    let __v_17: G = G::from_u64(72);
-    let __v_18: G = G::from_u64(118);
-    let __v_19: G = G::from_u64(81);
-    let __v_20: G = G::from_u64(240);
-    let __v_21: G = G::from_u64(5);
-    let __v_22: G = G::from_u64(154);
-    let __v_23: G = G::from_u64(125);
-    let __v_24: G = G::from_u64(243);
-    let __v_25: G = G::from_u64(189);
-    let __v_26: G = G::from_u64(168);
-    let __v_27: G = G::from_u64(91);
-    let __v_28: G = G::from_u64(51);
-    let __v_29: G = G::from_u64(31);
-    let __v_30: G = G::from_u64(103);
-    let __v_31: G = G::from_u64(230);
+    let __v_0: G = G::from_u64(212);
+    let __v_1: G = G::from_u64(148);
+    let __v_2: G = G::from_u64(220);
+    let __v_3: G = G::from_u64(96);
+    let __v_4: G = G::from_u64(19);
+    let __v_5: G = G::from_u64(134);
+    let __v_6: G = G::from_u64(186);
+    let __v_7: G = G::from_u64(142);
+    let __v_8: G = G::from_u64(143);
+    let __v_9: G = G::from_u64(11);
+    let __v_10: G = G::from_u64(113);
+    let __v_11: G = G::from_u64(31);
+    let __v_12: G = G::from_u64(230);
+    let __v_13: G = G::from_u64(42);
+    let __v_14: G = G::from_u64(45);
+    let __v_15: G = G::from_u64(96);
+    let __v_16: G = G::from_u64(171);
+    let __v_17: G = G::from_u64(96);
+    let __v_18: G = G::from_u64(198);
+    let __v_19: G = G::from_u64(72);
+    let __v_20: G = G::from_u64(140);
+    let __v_21: G = G::from_u64(140);
+    let __v_22: G = G::from_u64(246);
+    let __v_23: G = G::from_u64(206);
+    let __v_24: G = G::from_u64(151);
+    let __v_25: G = G::from_u64(121);
+    let __v_26: G = G::from_u64(110);
+    let __v_27: G = G::from_u64(188);
+    let __v_28: G = G::from_u64(58);
+    let __v_29: G = G::from_u64(213);
+    let __v_30: G = G::from_u64(254);
+    let __v_31: G = G::from_u64(251);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_521] = [__v_32];
-    record.function_queries[521].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_526] = [__v_32];
+    record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_522: usize = 0;
-const IN_522: usize = 0;
-const OUT_522: usize = 1;
-fn aiur_fn_522(
-  inp: [G; IN_522],
+const INPUT_SIZE_527: usize = 0;
+const IN_527: usize = 0;
+const OUT_527: usize = 1;
+fn aiur_fn_527(
+  inp: [G; IN_527],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_522], ExecError> {
+) -> Result<[G; OUT_527], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(122);
-    let __v_1: G = G::from_u64(6);
-    let __v_2: G = G::from_u64(73);
-    let __v_3: G = G::from_u64(109);
-    let __v_4: G = G::from_u64(7);
-    let __v_5: G = G::from_u64(181);
-    let __v_6: G = G::from_u64(151);
-    let __v_7: G = G::from_u64(16);
-    let __v_8: G = G::from_u64(52);
-    let __v_9: G = G::from_u64(138);
-    let __v_10: G = G::from_u64(95);
-    let __v_11: G = G::from_u64(101);
-    let __v_12: G = G::from_u64(120);
-    let __v_13: G = G::from_u64(81);
-    let __v_14: G = G::from_u64(164);
-    let __v_15: G = G::from_u64(238);
-    let __v_16: G = G::from_u64(161);
-    let __v_17: G = G::from_u64(245);
-    let __v_18: G = G::from_u64(148);
-    let __v_19: G = G::from_u64(146);
-    let __v_20: G = G::from_u64(165);
-    let __v_21: G = G::from_u64(183);
-    let __v_22: G = G::from_u64(222);
-    let __v_23: G = G::from_u64(63);
-    let __v_24: G = G::from_u64(81);
-    let __v_25: G = G::from_u64(171);
-    let __v_26: G = G::from_u64(188);
-    let __v_27: G = G::from_u64(132);
-    let __v_28: G = G::from_u64(249);
-    let __v_29: G = G::from_u64(188);
-    let __v_30: G = G::from_u64(29);
-    let __v_31: G = G::from_u64(23);
+    let __v_0: G = G::from_u64(252);
+    let __v_1: G = G::from_u64(140);
+    let __v_2: G = G::from_u64(68);
+    let __v_3: G = G::from_u64(204);
+    let __v_4: G = G::from_u64(151);
+    let __v_5: G = G::from_u64(12);
+    let __v_6: G = G::from_u64(252);
+    let __v_7: G = G::from_u64(24);
+    let __v_8: G = G::from_u64(60);
+    let __v_9: G = G::from_u64(205);
+    let __v_10: G = G::from_u64(16);
+    let __v_11: G = G::from_u64(162);
+    let __v_12: G = G::from_u64(209);
+    let __v_13: G = G::from_u64(205);
+    let __v_14: G = G::from_u64(235);
+    let __v_15: G = G::from_u64(44);
+    let __v_16: G = G::from_u64(132);
+    let __v_17: G = G::from_u64(147);
+    let __v_18: G = G::from_u64(7);
+    let __v_19: G = G::from_u64(118);
+    let __v_20: G = G::from_u64(14);
+    let __v_21: G = G::from_u64(145);
+    let __v_22: G = G::from_u64(245);
+    let __v_23: G = G::from_u64(205);
+    let __v_24: G = G::from_u64(41);
+    let __v_25: G = G::from_u64(162);
+    let __v_26: G = G::from_u64(176);
+    let __v_27: G = G::from_u64(47);
+    let __v_28: G = G::from_u64(112);
+    let __v_29: G = G::from_u64(109);
+    let __v_30: G = G::from_u64(131);
+    let __v_31: G = G::from_u64(218);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_522] = [__v_32];
-    record.function_queries[522].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_527] = [__v_32];
+    record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_523: usize = 0;
-const IN_523: usize = 0;
-const OUT_523: usize = 1;
-fn aiur_fn_523(
-  inp: [G; IN_523],
+const INPUT_SIZE_528: usize = 0;
+const IN_528: usize = 0;
+const OUT_528: usize = 1;
+fn aiur_fn_528(
+  inp: [G; IN_528],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_523], ExecError> {
+) -> Result<[G; OUT_528], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(20);
-    let __v_1: G = G::from_u64(236);
-    let __v_2: G = G::from_u64(206);
-    let __v_3: G = G::from_u64(225);
-    let __v_4: G = G::from_u64(222);
-    let __v_5: G = G::from_u64(186);
-    let __v_6: G = G::from_u64(5);
-    let __v_7: G = G::from_u64(233);
-    let __v_8: G = G::from_u64(68);
-    let __v_9: G = G::from_u64(59);
-    let __v_10: G = G::from_u64(209);
-    let __v_11: G = G::from_u64(105);
-    let __v_12: G = G::from_u64(208);
-    let __v_13: G = G::from_u64(14);
-    let __v_14: G = G::from_u64(214);
-    let __v_15: G = G::from_u64(52);
-    let __v_16: G = G::from_u64(23);
-    let __v_17: G = G::from_u64(14);
-    let __v_18: G = G::from_u64(50);
-    let __v_19: G = G::from_u64(70);
-    let __v_20: G = G::from_u64(179);
-    let __v_21: G = G::from_u64(121);
-    let __v_22: G = G::from_u64(33);
-    let __v_23: G = G::from_u64(25);
-    let __v_24: G = G::from_u64(158);
-    let __v_25: G = G::from_u64(219);
-    let __v_26: G = G::from_u64(186);
-    let __v_27: G = G::from_u64(211);
-    let __v_28: G = G::from_u64(246);
-    let __v_29: G = G::from_u64(125);
-    let __v_30: G = G::from_u64(181);
-    let __v_31: G = G::from_u64(180);
+    let __v_0: G = G::from_u64(252);
+    let __v_1: G = G::from_u64(223);
+    let __v_2: G = G::from_u64(24);
+    let __v_3: G = G::from_u64(96);
+    let __v_4: G = G::from_u64(173);
+    let __v_5: G = G::from_u64(76);
+    let __v_6: G = G::from_u64(214);
+    let __v_7: G = G::from_u64(114);
+    let __v_8: G = G::from_u64(35);
+    let __v_9: G = G::from_u64(147);
+    let __v_10: G = G::from_u64(146);
+    let __v_11: G = G::from_u64(230);
+    let __v_12: G = G::from_u64(14);
+    let __v_13: G = G::from_u64(123);
+    let __v_14: G = G::from_u64(73);
+    let __v_15: G = G::from_u64(224);
+    let __v_16: G = G::from_u64(36);
+    let __v_17: G = G::from_u64(175);
+    let __v_18: G = G::from_u64(4);
+    let __v_19: G = G::from_u64(117);
+    let __v_20: G = G::from_u64(115);
+    let __v_21: G = G::from_u64(156);
+    let __v_22: G = G::from_u64(58);
+    let __v_23: G = G::from_u64(64);
+    let __v_24: G = G::from_u64(25);
+    let __v_25: G = G::from_u64(90);
+    let __v_26: G = G::from_u64(145);
+    let __v_27: G = G::from_u64(78);
+    let __v_28: G = G::from_u64(174);
+    let __v_29: G = G::from_u64(196);
+    let __v_30: G = G::from_u64(44);
+    let __v_31: G = G::from_u64(4);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_523] = [__v_32];
-    record.function_queries[523].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_528] = [__v_32];
+    record.function_queries[528].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_524: usize = 0;
-const IN_524: usize = 0;
-const OUT_524: usize = 1;
-fn aiur_fn_524(
-  inp: [G; IN_524],
+const INPUT_SIZE_529: usize = 0;
+const IN_529: usize = 0;
+const OUT_529: usize = 1;
+fn aiur_fn_529(
+  inp: [G; IN_529],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_524], ExecError> {
+) -> Result<[G; OUT_529], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(173);
-    let __v_1: G = G::from_u64(50);
-    let __v_2: G = G::from_u64(192);
-    let __v_3: G = G::from_u64(93);
-    let __v_4: G = G::from_u64(126);
-    let __v_5: G = G::from_u64(60);
-    let __v_6: G = G::from_u64(93);
-    let __v_7: G = G::from_u64(223);
-    let __v_8: G = G::from_u64(78);
-    let __v_9: G = G::from_u64(76);
-    let __v_10: G = G::from_u64(133);
-    let __v_11: G = G::from_u64(207);
-    let __v_12: G = G::from_u64(143);
-    let __v_13: G = G::from_u64(96);
-    let __v_14: G = G::from_u64(216);
-    let __v_15: G = G::from_u64(62);
-    let __v_16: G = G::from_u64(15);
-    let __v_17: G = G::from_u64(186);
-    let __v_18: G = G::from_u64(85);
-    let __v_19: G = G::from_u64(226);
-    let __v_20: G = G::from_u64(103);
-    let __v_21: G = G::from_u64(107);
-    let __v_22: G = G::from_u64(248);
-    let __v_23: G = G::from_u64(161);
-    let __v_24: G = G::from_u64(230);
-    let __v_25: G = G::from_u64(8);
-    let __v_26: G = G::from_u64(219);
-    let __v_27: G = G::from_u64(84);
-    let __v_28: G = G::from_u64(177);
-    let __v_29: G = G::from_u64(103);
-    let __v_30: G = G::from_u64(201);
-    let __v_31: G = G::from_u64(250);
+    let __v_0: G = G::from_u64(29);
+    let __v_1: G = G::from_u64(84);
+    let __v_2: G = G::from_u64(128);
+    let __v_3: G = G::from_u64(106);
+    let __v_4: G = G::from_u64(177);
+    let __v_5: G = G::from_u64(235);
+    let __v_6: G = G::from_u64(199);
+    let __v_7: G = G::from_u64(145);
+    let __v_8: G = G::from_u64(225);
+    let __v_9: G = G::from_u64(219);
+    let __v_10: G = G::from_u64(150);
+    let __v_11: G = G::from_u64(232);
+    let __v_12: G = G::from_u64(141);
+    let __v_13: G = G::from_u64(4);
+    let __v_14: G = G::from_u64(7);
+    let __v_15: G = G::from_u64(206);
+    let __v_16: G = G::from_u64(243);
+    let __v_17: G = G::from_u64(82);
+    let __v_18: G = G::from_u64(57);
+    let __v_19: G = G::from_u64(39);
+    let __v_20: G = G::from_u64(214);
+    let __v_21: G = G::from_u64(11);
+    let __v_22: G = G::from_u64(166);
+    let __v_23: G = G::from_u64(105);
+    let __v_24: G = G::from_u64(104);
+    let __v_25: G = G::from_u64(155);
+    let __v_26: G = G::from_u64(146);
+    let __v_27: G = G::from_u64(168);
+    let __v_28: G = G::from_u64(238);
+    let __v_29: G = G::from_u64(179);
+    let __v_30: G = G::from_u64(100);
+    let __v_31: G = G::from_u64(69);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_524] = [__v_32];
-    record.function_queries[524].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_529] = [__v_32];
+    record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_525: usize = 1;
-const IN_525: usize = 1;
-const OUT_525: usize = 1;
-fn aiur_fn_525(
-  inp: [G; IN_525],
+const INPUT_SIZE_530: usize = 1;
+const IN_530: usize = 1;
+const OUT_530: usize = 1;
+fn aiur_fn_530(
+  inp: [G; IN_530],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_525], ExecError> {
+) -> Result<[G; OUT_530], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = []; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_525] = [__v_3];
-        record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_530] = [__v_3];
+        record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = []; let __cu = unconstrained; let __hit = record.function_queries[517].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { *(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517]) }; __ret }, _ => aiur_fn_517(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_525] = [__v_5];
-            record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_530] = [__v_5];
+            record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = []; let __cu = unconstrained; let __hit = record.function_queries[518].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { *(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518]) }; __ret }, _ => aiur_fn_518(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_525] = [__v_7];
-                record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_530] = [__v_7];
+                record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = []; let __cu = unconstrained; let __hit = record.function_queries[523].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { *(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523]) }; __ret }, _ => aiur_fn_523(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
                 match __v_8.as_canonical_u64() {
                   1u64 => {
                     let __v_9: G = G::from_u64(1);
-                    let __ret: [G; OUT_525] = [__v_9];
-                    record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_530] = [__v_9];
+                    record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; let __hit = record.function_queries[522].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { *(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522]) }; __ret }, _ => aiur_fn_522(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } };
                     let __v_9: G = __r_arr[0];
                     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                     let __v_10: G = __r_arr[0];
                     match __v_10.as_canonical_u64() {
                       1u64 => {
                         let __v_11: G = G::from_u64(1);
-                        let __ret: [G; OUT_525] = [__v_11];
-                        record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_530] = [__v_11];
+                        record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = []; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } };
                         let __v_11: G = __r_arr[0];
                         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
                         let __v_12: G = __r_arr[0];
                         match __v_12.as_canonical_u64() {
                           1u64 => {
                             let __v_13: G = G::from_u64(1);
-                            let __ret: [G; OUT_525] = [__v_13];
-                            record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_530] = [__v_13];
+                            record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_13: G = G::from_u64(0);
-                            let __ret: [G; OUT_525] = [__v_13];
-                            record.function_queries[525].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_530] = [__v_13];
+                            record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -45847,56 +46035,56 @@ fn aiur_fn_525(
   })
 }
 
-const INPUT_SIZE_526: usize = 1;
-const IN_526: usize = 1;
-const OUT_526: usize = 1;
-fn aiur_fn_526(
-  inp: [G; IN_526],
+const INPUT_SIZE_531: usize = 1;
+const IN_531: usize = 1;
+const OUT_531: usize = 1;
+fn aiur_fn_531(
+  inp: [G; IN_531],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_526], ExecError> {
+) -> Result<[G; OUT_531], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = []; let __cu = unconstrained; let __hit = record.function_queries[523].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { *(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523]) }; __ret }, _ => aiur_fn_523(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = []; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_526] = [__v_3];
-        record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_531] = [__v_3];
+        record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; let __hit = record.function_queries[522].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { *(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522]) }; __ret }, _ => aiur_fn_522(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = []; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_526] = [__v_5];
-            record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_531] = [__v_5];
+            record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = []; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = []; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
             match __v_6.as_canonical_u64() {
               1u64 => {
                 let __v_7: G = G::from_u64(1);
-                let __ret: [G; OUT_526] = [__v_7];
-                record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_531] = [__v_7];
+                record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_526] = [__v_7];
-                record.function_queries[526].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_531] = [__v_7];
+                record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -45907,15 +46095,15 @@ fn aiur_fn_526(
   })
 }
 
-const INPUT_SIZE_527: usize = 1;
-const IN_527: usize = 1;
-const OUT_527: usize = 3;
-fn aiur_fn_527(
-  inp: [G; IN_527],
+const INPUT_SIZE_532: usize = 1;
+const IN_532: usize = 1;
+const OUT_532: usize = 3;
+fn aiur_fn_532(
+  inp: [G; IN_532],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_527], ExecError> {
+) -> Result<[G; OUT_532], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -45932,11 +46120,11 @@ fn aiur_fn_527(
         let __v_8: G = __loaded[3];
         match __v_5.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_6, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
@@ -45948,8 +46136,8 @@ fn aiur_fn_527(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_527] = [__v_14, __v_15, __v_18];
-                record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_532] = [__v_14, __v_15, __v_18];
+                record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -45963,8 +46151,8 @@ fn aiur_fn_527(
                     match __v_15.as_canonical_u64() {
                       0u64 => {
                         let __v_18: G = G::from_u64(1);
-                        let __ret: [G; OUT_527] = [__v_18, __v_12, __v_16];
-                        record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_532] = [__v_18, __v_12, __v_16];
+                        record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -45973,8 +46161,8 @@ fn aiur_fn_527(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_527] = [__v_18, __v_19, __v_22];
-                        record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_532] = [__v_18, __v_19, __v_22];
+                        record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -45985,8 +46173,8 @@ fn aiur_fn_527(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_527] = [__v_18, __v_19, __v_22];
-                    record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_532] = [__v_18, __v_19, __v_22];
+                    record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -45999,8 +46187,8 @@ fn aiur_fn_527(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_527] = [__v_9, __v_10, __v_13];
-            record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_532] = [__v_9, __v_10, __v_13];
+            record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -46011,34 +46199,34 @@ fn aiur_fn_527(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_527] = [__v_5, __v_6, __v_9];
-        record.function_queries[527].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_532] = [__v_5, __v_6, __v_9];
+        record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_528: usize = 2;
-const IN_528: usize = 2;
-const OUT_528: usize = 1;
-fn aiur_fn_528(
-  inp: [G; IN_528],
+const INPUT_SIZE_533: usize = 2;
+const IN_533: usize = 2;
+const OUT_533: usize = 1;
+fn aiur_fn_533(
+  inp: [G; IN_533],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_528], ExecError> {
+) -> Result<[G; OUT_533], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = []; let __cu = unconstrained; let __hit = record.function_queries[150].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[150].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[150].bump_multiplicity(__i); } let __ret: [G; OUT_150] = unsafe { *(record.function_queries[150].output_at(__i).as_ptr() as *const [G; OUT_150]) }; __ret }, _ => aiur_fn_150(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = []; let __cu = unconstrained; let __hit = record.function_queries[155].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[155].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[155].bump_multiplicity(__i); } let __ret: [G; OUT_155] = unsafe { *(record.function_queries[155].output_at(__i).as_ptr() as *const [G; OUT_155]) }; __ret }, _ => aiur_fn_155(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
   _ => {
-    let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = []; let __cu = unconstrained; let __hit = record.function_queries[151].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[151].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[151].bump_multiplicity(__i); } let __ret: [G; OUT_151] = unsafe { *(record.function_queries[151].output_at(__i).as_ptr() as *const [G; OUT_151]) }; __ret }, _ => aiur_fn_151(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = []; let __cu = unconstrained; let __hit = record.function_queries[156].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[156].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[156].bump_multiplicity(__i); } let __ret: [G; OUT_156] = unsafe { *(record.function_queries[156].output_at(__i).as_ptr() as *const [G; OUT_156]) }; __ret }, _ => aiur_fn_156(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
     break '__mc_0 [__v_2];
   },
@@ -46058,27 +46246,27 @@ fn aiur_fn_528(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_528] = [__v_15];
-    record.function_queries[528].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_533] = [__v_15];
+    record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_529: usize = 4;
-const IN_529: usize = 4;
-const OUT_529: usize = 2;
-fn aiur_fn_529(
-  inp: [G; IN_529],
+const INPUT_SIZE_534: usize = 4;
+const IN_534: usize = 4;
+const OUT_534: usize = 2;
+fn aiur_fn_534(
+  inp: [G; IN_534],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_529], ExecError> {
+) -> Result<[G; OUT_534], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -46089,24 +46277,24 @@ fn aiur_fn_529(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_529] = [__v_7, __v_11];
-        record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_534] = [__v_7, __v_11];
+        record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_7: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__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];
@@ -46117,26 +46305,26 @@ fn aiur_fn_529(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_529] = [__v_17, __v_21];
-                record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_534] = [__v_17, __v_21];
+                record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } };
                 let __v_17: G = __r_arr[0];
                 let __v_18: G = __r_arr[1];
-                let __ret: [G; OUT_529] = [__v_17, __v_18];
-                record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_534] = [__v_17, __v_18];
+                record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[530].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[530].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[530].bump_multiplicity(__i); } let __ret: [G; OUT_530] = unsafe { *(record.function_queries[530].output_at(__i).as_ptr() as *const [G; OUT_530]) }; __ret }, _ => aiur_fn_530(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0, __v_1, __v_2, __v_8, __v_10, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[535].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[535].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[535].bump_multiplicity(__i); } let __ret: [G; OUT_535] = unsafe { *(record.function_queries[535].output_at(__i).as_ptr() as *const [G; OUT_535]) }; __ret }, _ => aiur_fn_535(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_529] = [__v_14, __v_15];
-            record.function_queries[529].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_534] = [__v_14, __v_15];
+            record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -46145,15 +46333,15 @@ fn aiur_fn_529(
   })
 }
 
-const INPUT_SIZE_530: usize = 6;
-const IN_530: usize = 6;
-const OUT_530: usize = 2;
-fn aiur_fn_530(
-  inp: [G; IN_530],
+const INPUT_SIZE_535: usize = 6;
+const IN_535: usize = 6;
+const OUT_535: usize = 2;
+fn aiur_fn_535(
+  inp: [G; IN_535],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_530], ExecError> {
+) -> Result<[G; OUT_535], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46161,25 +46349,25 @@ fn aiur_fn_530(
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
     let __v_5: G = inp[5];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__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];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[527].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[527].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[527].bump_multiplicity(__i); } let __ret: [G; OUT_527] = unsafe { *(record.function_queries[527].output_at(__i).as_ptr() as *const [G; OUT_527]) }; __ret }, _ => aiur_fn_527(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
         match __v_11.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[528].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[528].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[528].bump_multiplicity(__i); } let __ret: [G; OUT_528] = unsafe { *(record.function_queries[528].output_at(__i).as_ptr() as *const [G; OUT_528]) }; __ret }, _ => aiur_fn_528(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = G::from_u64(2);
             let __v_17: G = G::from_u64(0);
@@ -46191,13 +46379,13 @@ fn aiur_fn_530(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
             let __v_25: G = G::from_u64(2);
-            let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_2, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_24, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_24, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __ret: [G; OUT_530] = [__v_27, __v_28];
-            record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_535] = [__v_27, __v_28];
+            record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -46206,8 +46394,8 @@ fn aiur_fn_530(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_530] = [__v_14, __v_18];
-            record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_535] = [__v_14, __v_18];
+            record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -46218,29 +46406,29 @@ fn aiur_fn_530(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_530] = [__v_11, __v_15];
-        record.function_queries[530].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_535] = [__v_11, __v_15];
+        record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_531: usize = 4;
-const IN_531: usize = 4;
-const OUT_531: usize = 2;
-fn aiur_fn_531(
-  inp: [G; IN_531],
+const INPUT_SIZE_536: usize = 4;
+const IN_536: usize = 4;
+const OUT_536: usize = 2;
+fn aiur_fn_536(
+  inp: [G; IN_536],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_531], ExecError> {
+) -> Result<[G; OUT_536], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -46251,50 +46439,50 @@ fn aiur_fn_531(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_531] = [__v_7, __v_11];
-        record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_536] = [__v_7, __v_11];
+        record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[526].bump_multiplicity(__i); } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[531].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[531].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[531].bump_multiplicity(__i); } let __ret: [G; OUT_531] = unsafe { *(record.function_queries[531].output_at(__i).as_ptr() as *const [G; OUT_531]) }; __ret }, _ => aiur_fn_531(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         match __v_7.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[529].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[529].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[529].bump_multiplicity(__i); } let __ret: [G; OUT_529] = unsafe { *(record.function_queries[529].output_at(__i).as_ptr() as *const [G; OUT_529]) }; __ret }, _ => aiur_fn_529(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[534].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i); } let __ret: [G; OUT_534] = unsafe { *(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534]) }; __ret }, _ => aiur_fn_534(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __ret: [G; OUT_531] = [__v_8, __v_9];
-            record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_536] = [__v_8, __v_9];
+            record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = []; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = []; let __cu = unconstrained; let __hit = record.function_queries[512].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[512].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[512].bump_multiplicity(__i); } let __ret: [G; OUT_512] = unsafe { *(record.function_queries[512].output_at(__i).as_ptr() as *const [G; OUT_512]) }; __ret }, _ => aiur_fn_512(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = []; let __cu = unconstrained; let __hit = record.function_queries[517].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { *(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517]) }; __ret }, _ => aiur_fn_517(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = []; let __cu = unconstrained; let __hit = record.function_queries[513].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[513].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[513].bump_multiplicity(__i); } let __ret: [G; OUT_513] = unsafe { *(record.function_queries[513].output_at(__i).as_ptr() as *const [G; OUT_513]) }; __ret }, _ => aiur_fn_513(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = []; let __cu = unconstrained; let __hit = record.function_queries[518].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { *(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518]) }; __ret }, _ => aiur_fn_518(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             match __v_13.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_532] = { let __args: [G; IN_532] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[532].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[532].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[532].bump_multiplicity(__i); } let __ret: [G; OUT_532] = unsafe { *(record.function_queries[532].output_at(__i).as_ptr() as *const [G; OUT_532]) }; __ret }, _ => aiur_fn_532(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[537].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i); } let __ret: [G; OUT_537] = unsafe { *(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537]) }; __ret }, _ => aiur_fn_537(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
-                let __ret: [G; OUT_531] = [__v_14, __v_15];
-                record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_536] = [__v_14, __v_15];
+                record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[533].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[533].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[533].bump_multiplicity(__i); } let __ret: [G; OUT_533] = unsafe { *(record.function_queries[533].output_at(__i).as_ptr() as *const [G; OUT_533]) }; __ret }, _ => aiur_fn_533(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_9, __v_11, __v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
                 let __v_14: G = __r_arr[0];
                 let __v_15: G = __r_arr[1];
-                let __ret: [G; OUT_531] = [__v_14, __v_15];
-                record.function_queries[531].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_536] = [__v_14, __v_15];
+                record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -46305,28 +46493,28 @@ fn aiur_fn_531(
   })
 }
 
-const INPUT_SIZE_532: usize = 3;
-const IN_532: usize = 3;
-const OUT_532: usize = 2;
-fn aiur_fn_532(
-  inp: [G; IN_532],
+const INPUT_SIZE_537: usize = 3;
+const IN_537: usize = 3;
+const OUT_537: usize = 2;
+fn aiur_fn_537(
+  inp: [G; IN_537],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_532], ExecError> {
+) -> Result<[G; OUT_537], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
     let __v_9: G = __r_arr[1];
     match __v_8.as_canonical_u64() {
@@ -46336,17 +46524,17 @@ fn aiur_fn_532(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_532] = [__v_10, __v_14];
-        record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_537] = [__v_10, __v_14];
+        record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[116].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[116].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[116].bump_multiplicity(__i); } let __ret: [G; OUT_116] = unsafe { *(record.function_queries[116].output_at(__i).as_ptr() as *const [G; OUT_116]) }; __ret }, _ => aiur_fn_116(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[121].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[121].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[121].bump_multiplicity(__i); } let __ret: [G; OUT_121] = unsafe { *(record.function_queries[121].output_at(__i).as_ptr() as *const [G; OUT_121]) }; __ret }, _ => aiur_fn_121(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[245].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[245].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[245].bump_multiplicity(__i); } let __ret: [G; OUT_245] = unsafe { *(record.function_queries[245].output_at(__i).as_ptr() as *const [G; OUT_245]) }; __ret }, _ => aiur_fn_245(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[250].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[250].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[250].bump_multiplicity(__i); } let __ret: [G; OUT_250] = unsafe { *(record.function_queries[250].output_at(__i).as_ptr() as *const [G; OUT_250]) }; __ret }, _ => aiur_fn_250(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(2);
-        let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = []; let __cu = unconstrained; let __hit = record.function_queries[511].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[511].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[511].bump_multiplicity(__i); } let __ret: [G; OUT_511] = unsafe { *(record.function_queries[511].output_at(__i).as_ptr() as *const [G; OUT_511]) }; __ret }, _ => aiur_fn_511(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = []; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
@@ -46357,13 +46545,13 @@ fn aiur_fn_532(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_22: G = G::from_u64(2);
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_1, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_21, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_21, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __ret: [G; OUT_532] = [__v_24, __v_25];
-        record.function_queries[532].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_537] = [__v_24, __v_25];
+        record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -46373,15 +46561,15 @@ fn aiur_fn_532(
   })
 }
 
-const INPUT_SIZE_533: usize = 6;
-const IN_533: usize = 6;
-const OUT_533: usize = 2;
-fn aiur_fn_533(
-  inp: [G; IN_533],
+const INPUT_SIZE_538: usize = 6;
+const IN_538: usize = 6;
+const OUT_538: usize = 2;
+fn aiur_fn_538(
+  inp: [G; IN_538],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_533], ExecError> {
+) -> Result<[G; OUT_538], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46390,16 +46578,16 @@ fn aiur_fn_533(
     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_777] = { let __args: [G; IN_777] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
     let __v_9: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_7, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_7, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_9, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_9, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = __r_arr[1];
     match __v_12.as_canonical_u64() {
@@ -46409,12 +46597,12 @@ fn aiur_fn_533(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_533] = [__v_14, __v_18];
-        record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_538] = [__v_14, __v_18];
+        record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[243].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[243].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[243].bump_multiplicity(__i); } let __ret: [G; OUT_243] = unsafe { *(record.function_queries[243].output_at(__i).as_ptr() as *const [G; OUT_243]) }; __ret }, _ => aiur_fn_243(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[248].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[248].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[248].bump_multiplicity(__i); } let __ret: [G; OUT_248] = unsafe { *(record.function_queries[248].output_at(__i).as_ptr() as *const [G; OUT_248]) }; __ret }, _ => aiur_fn_248(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
         match __v_14.as_canonical_u64() {
@@ -46424,30 +46612,30 @@ fn aiur_fn_533(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_533] = [__v_16, __v_20];
-            record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_538] = [__v_16, __v_20];
+            record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[124].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[124].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[124].bump_multiplicity(__i); } let __ret: [G; OUT_124] = unsafe { *(record.function_queries[124].output_at(__i).as_ptr() as *const [G; OUT_124]) }; __ret }, _ => aiur_fn_124(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[129].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[129].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[129].bump_multiplicity(__i); } let __ret: [G; OUT_129] = unsafe { *(record.function_queries[129].output_at(__i).as_ptr() as *const [G; OUT_129]) }; __ret }, _ => aiur_fn_129(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
   _ => {
-    let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[338].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[338].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[338].bump_multiplicity(__i); } let __ret: [G; OUT_338] = unsafe { *(record.function_queries[338].output_at(__i).as_ptr() as *const [G; OUT_338]) }; __ret }, _ => aiur_fn_338(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_13, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[343].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[343].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[343].bump_multiplicity(__i); } let __ret: [G; OUT_343] = unsafe { *(record.function_queries[343].output_at(__i).as_ptr() as *const [G; OUT_343]) }; __ret }, _ => aiur_fn_343(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
 }
  };
             let __v_16: G = __mc_out___mc_0[0];
-            let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[534].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[534].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[534].bump_multiplicity(__i); } let __ret: [G; OUT_534] = unsafe { *(record.function_queries[534].output_at(__i).as_ptr() as *const [G; OUT_534]) }; __ret }, _ => aiur_fn_534(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_0, __v_1, __v_16, __v_7, __v_9, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_533] = [__v_17, __v_18];
-            record.function_queries[533].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_538] = [__v_17, __v_18];
+            record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -46462,15 +46650,15 @@ fn aiur_fn_533(
   })
 }
 
-const INPUT_SIZE_534: usize = 9;
-const IN_534: usize = 9;
-const OUT_534: usize = 2;
-fn aiur_fn_534(
-  inp: [G; IN_534],
+const INPUT_SIZE_539: usize = 9;
+const IN_539: usize = 9;
+const OUT_539: usize = 2;
+fn aiur_fn_539(
+  inp: [G; IN_539],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_534], ExecError> {
+) -> Result<[G; OUT_539], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46491,8 +46679,8 @@ fn aiur_fn_534(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_534] = [__v_12, __v_16];
-        record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_539] = [__v_12, __v_16];
+        record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -46508,12 +46696,12 @@ fn aiur_fn_534(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_23: G = G::from_u64(2);
-        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = []; let __cu = unconstrained; let __hit = record.function_queries[521].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[521].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { *(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521]) }; __ret }, _ => aiur_fn_521(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[526].bump_multiplicity(__i); } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_27: G = G::from_u64(2);
-        let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = []; let __cu = unconstrained; let __hit = record.function_queries[520].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[520].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { *(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520]) }; __ret }, _ => aiur_fn_520(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = []; let __cu = unconstrained; let __hit = record.function_queries[525].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[525].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[525].bump_multiplicity(__i); } let __ret: [G; OUT_525] = unsafe { *(record.function_queries[525].output_at(__i).as_ptr() as *const [G; OUT_525]) }; __ret }, _ => aiur_fn_525(__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);
@@ -46522,12 +46710,12 @@ fn aiur_fn_534(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = []; let __cu = unconstrained; let __hit = record.function_queries[176].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[176].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[176].bump_multiplicity(__i); } let __ret: [G; OUT_176] = unsafe { *(record.function_queries[176].output_at(__i).as_ptr() as *const [G; OUT_176]) }; __ret }, _ => aiur_fn_176(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = []; let __cu = unconstrained; let __hit = record.function_queries[181].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[181].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[181].bump_multiplicity(__i); } let __ret: [G; OUT_181] = unsafe { *(record.function_queries[181].output_at(__i).as_ptr() as *const [G; OUT_181]) }; __ret }, _ => aiur_fn_181(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
     break '__mc_0 [__v_34];
   },
   _ => {
-    let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = []; let __cu = unconstrained; let __hit = record.function_queries[177].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[177].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[177].bump_multiplicity(__i); } let __ret: [G; OUT_177] = unsafe { *(record.function_queries[177].output_at(__i).as_ptr() as *const [G; OUT_177]) }; __ret }, _ => aiur_fn_177(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = []; let __cu = unconstrained; let __hit = record.function_queries[182].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[182].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[182].bump_multiplicity(__i); } let __ret: [G; OUT_182] = unsafe { *(record.function_queries[182].output_at(__i).as_ptr() as *const [G; OUT_182]) }; __ret }, _ => aiur_fn_182(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
     break '__mc_0 [__v_34];
   },
@@ -46550,12 +46738,12 @@ fn aiur_fn_534(
   1u64 => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = []; let __cu = unconstrained; let __hit = record.function_queries[516].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[516].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[516].bump_multiplicity(__i); } let __ret: [G; OUT_516] = unsafe { *(record.function_queries[516].output_at(__i).as_ptr() as *const [G; OUT_516]) }; __ret }, _ => aiur_fn_516(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = []; let __cu = unconstrained; let __hit = record.function_queries[521].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[521].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { *(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521]) }; __ret }, _ => aiur_fn_521(__args, record, io_buffer, __cu)? } };
         let __v_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
       _ => {
-        let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = []; let __cu = unconstrained; let __hit = record.function_queries[517].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[517].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[517].bump_multiplicity(__i); } let __ret: [G; OUT_517] = unsafe { *(record.function_queries[517].output_at(__i).as_ptr() as *const [G; OUT_517]) }; __ret }, _ => aiur_fn_517(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = []; let __cu = unconstrained; let __hit = record.function_queries[522].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[522].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[522].bump_multiplicity(__i); } let __ret: [G; OUT_522] = unsafe { *(record.function_queries[522].output_at(__i).as_ptr() as *const [G; OUT_522]) }; __ret }, _ => aiur_fn_522(__args, record, io_buffer, __cu)? } };
         let __v_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
@@ -46564,12 +46752,12 @@ fn aiur_fn_534(
   _ => {
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = []; let __cu = unconstrained; let __hit = record.function_queries[518].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[518].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[518].bump_multiplicity(__i); } let __ret: [G; OUT_518] = unsafe { *(record.function_queries[518].output_at(__i).as_ptr() as *const [G; OUT_518]) }; __ret }, _ => aiur_fn_518(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = []; let __cu = unconstrained; let __hit = record.function_queries[523].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[523].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[523].bump_multiplicity(__i); } let __ret: [G; OUT_523] = unsafe { *(record.function_queries[523].output_at(__i).as_ptr() as *const [G; OUT_523]) }; __ret }, _ => aiur_fn_523(__args, record, io_buffer, __cu)? } };
         let __v_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
       _ => {
-        let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __cu = unconstrained; let __hit = record.function_queries[519].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { *(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519]) }; __ret }, _ => aiur_fn_519(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = []; let __cu = unconstrained; let __hit = record.function_queries[524].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[524].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[524].bump_multiplicity(__i); } let __ret: [G; OUT_524] = unsafe { *(record.function_queries[524].output_at(__i).as_ptr() as *const [G; OUT_524]) }; __ret }, _ => aiur_fn_524(__args, record, io_buffer, __cu)? } };
         let __v_47: G = __r_arr[0];
         break '__mc_1 [__v_47];
       },
@@ -46593,31 +46781,31 @@ fn aiur_fn_534(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[537].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[537].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[537].bump_multiplicity(__i); } let __ret: [G; OUT_537] = unsafe { *(record.function_queries[537].output_at(__i).as_ptr() as *const [G; OUT_537]) }; __ret }, _ => aiur_fn_537(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_2, __v_62, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
         let __v_63: G = __r_arr[0];
         let __v_64: G = __r_arr[1];
-        let __ret: [G; OUT_534] = [__v_63, __v_64];
-        record.function_queries[534].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_539] = [__v_63, __v_64];
+        record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_535: usize = 3;
-const IN_535: usize = 3;
-const OUT_535: usize = 2;
-fn aiur_fn_535(
-  inp: [G; IN_535],
+const INPUT_SIZE_540: usize = 3;
+const IN_540: usize = 3;
+const OUT_540: usize = 2;
+fn aiur_fn_540(
+  inp: [G; IN_540],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_535], ExecError> {
+) -> Result<[G; OUT_540], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -46628,16 +46816,16 @@ fn aiur_fn_535(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_535] = [__v_6, __v_10];
-        record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_540] = [__v_6, __v_10];
+        record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_777] = { let __args: [G; IN_777] = [__v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_10: G = __loaded[0];
@@ -46657,7 +46845,7 @@ fn aiur_fn_535(
                   7u64 => {
                     match __v_15.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
                         let __v_18: G = __r_arr[0];
                         match __v_18.as_canonical_u64() {
                           0u64 => {
@@ -46666,16 +46854,16 @@ fn aiur_fn_535(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_535] = [__v_19, __v_23];
-                            record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_540] = [__v_19, __v_23];
+                            record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
-                            let __r_arr: [G; OUT_536] = { let __args: [G; IN_536] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[536].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[536].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[536].bump_multiplicity(__i); } let __ret: [G; OUT_536] = unsafe { *(record.function_queries[536].output_at(__i).as_ptr() as *const [G; OUT_536]) }; __ret }, _ => aiur_fn_536(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_12, __v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
                             let __v_19: G = __r_arr[0];
                             let __v_20: G = __r_arr[1];
-                            let __ret: [G; OUT_535] = [__v_19, __v_20];
-                            record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_540] = [__v_19, __v_20];
+                            record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -46686,8 +46874,8 @@ fn aiur_fn_535(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_535] = [__v_18, __v_22];
-                        record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_540] = [__v_18, __v_22];
+                        record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -46698,8 +46886,8 @@ fn aiur_fn_535(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_535] = [__v_18, __v_22];
-                    record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_540] = [__v_18, __v_22];
+                    record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -46710,8 +46898,8 @@ fn aiur_fn_535(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_535] = [__v_14, __v_18];
-                record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_540] = [__v_14, __v_18];
+                record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -46722,8 +46910,8 @@ fn aiur_fn_535(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_535] = [__v_14, __v_18];
-            record.function_queries[535].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_540] = [__v_14, __v_18];
+            record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -46732,15 +46920,15 @@ fn aiur_fn_535(
   })
 }
 
-const INPUT_SIZE_536: usize = 4;
-const IN_536: usize = 4;
-const OUT_536: usize = 2;
-fn aiur_fn_536(
-  inp: [G; IN_536],
+const INPUT_SIZE_541: usize = 4;
+const IN_541: usize = 4;
+const OUT_541: usize = 2;
+fn aiur_fn_541(
+  inp: [G; IN_541],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_536], ExecError> {
+) -> Result<[G; OUT_541], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46758,12 +46946,12 @@ fn aiur_fn_536(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_15: G = G::from_u64(2);
-    let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = []; let __cu = unconstrained; let __hit = record.function_queries[521].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[521].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[521].bump_multiplicity(__i); } let __ret: [G; OUT_521] = unsafe { *(record.function_queries[521].output_at(__i).as_ptr() as *const [G; OUT_521]) }; __ret }, _ => aiur_fn_521(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = []; let __cu = unconstrained; let __hit = record.function_queries[526].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[526].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[526].bump_multiplicity(__i); } let __ret: [G; OUT_526] = unsafe { *(record.function_queries[526].output_at(__i).as_ptr() as *const [G; OUT_526]) }; __ret }, _ => aiur_fn_526(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_19: G = G::from_u64(2);
-    let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = []; let __cu = unconstrained; let __hit = record.function_queries[218].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[218].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[218].bump_multiplicity(__i); } let __ret: [G; OUT_218] = unsafe { *(record.function_queries[218].output_at(__i).as_ptr() as *const [G; OUT_218]) }; __ret }, _ => aiur_fn_218(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = []; let __cu = unconstrained; let __hit = record.function_queries[223].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[223].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[223].bump_multiplicity(__i); } let __ret: [G; OUT_223] = unsafe { *(record.function_queries[223].output_at(__i).as_ptr() as *const [G; OUT_223]) }; __ret }, _ => aiur_fn_223(__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);
@@ -46787,18 +46975,18 @@ fn aiur_fn_536(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_785] = { let __args: [G; IN_785] = [__v_2, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_2, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
     let __v_43: G = __r_arr[0];
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_41, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_41, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
     let __v_44: G = __r_arr[0];
-    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_44, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_44, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_45: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_45, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_45, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_46: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_47: G = __r_arr[0];
     let __v_48: G = __r_arr[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -46809,16 +46997,16 @@ fn aiur_fn_536(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_536] = [__v_52, __v_56];
-        record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_541] = [__v_52, __v_56];
+        record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_52: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_48, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_48, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_53: G = __r_arr[0];
         let __v_54: G = G::from_u64(2);
-        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __cu = unconstrained; let __hit = record.function_queries[519].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { *(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519]) }; __ret }, _ => aiur_fn_519(__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);
@@ -46832,28 +47020,28 @@ fn aiur_fn_536(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_786] = { let __args: [G; IN_786] = [__v_2, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_2, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_66, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_66, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_70: G = __r_arr[0];
-        let __ret: [G; OUT_536] = [__v_69, __v_70];
-        record.function_queries[536].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_541] = [__v_69, __v_70];
+        record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_537: usize = 6;
-const IN_537: usize = 6;
-const OUT_537: usize = 2;
-fn aiur_fn_537(
-  inp: [G; IN_537],
+const INPUT_SIZE_542: usize = 6;
+const IN_542: usize = 6;
+const OUT_542: usize = 2;
+fn aiur_fn_542(
+  inp: [G; IN_542],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_537], ExecError> {
+) -> Result<[G; OUT_542], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46863,12 +47051,12 @@ fn aiur_fn_537(
     let __v_5: G = inp[5];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = []; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = []; let __cu = unconstrained; let __hit = record.function_queries[519].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[519].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[519].bump_multiplicity(__i); } let __ret: [G; OUT_519] = unsafe { *(record.function_queries[519].output_at(__i).as_ptr() as *const [G; OUT_519]) }; __ret }, _ => aiur_fn_519(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     break '__mc_0 [__v_6];
   },
   _ => {
-    let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = []; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = []; let __cu = unconstrained; let __hit = record.function_queries[520].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[520].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[520].bump_multiplicity(__i); } let __ret: [G; OUT_520] = unsafe { *(record.function_queries[520].output_at(__i).as_ptr() as *const [G; OUT_520]) }; __ret }, _ => aiur_fn_520(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     break '__mc_0 [__v_6];
   },
@@ -46879,18 +47067,18 @@ fn aiur_fn_537(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __v_10: G = G::from_u64(2);
-    let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
-    let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[487].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[487].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[487].bump_multiplicity(__i); } let __ret: [G; OUT_487] = unsafe { *(record.function_queries[487].output_at(__i).as_ptr() as *const [G; OUT_487]) }; __ret }, _ => aiur_fn_487(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_12, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[492].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[492].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[492].bump_multiplicity(__i); } let __ret: [G; OUT_492] = unsafe { *(record.function_queries[492].output_at(__i).as_ptr() as *const [G; OUT_492]) }; __ret }, _ => aiur_fn_492(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_16]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
@@ -46901,13 +47089,13 @@ fn aiur_fn_537(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_537] = [__v_20, __v_24];
-        record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_542] = [__v_20, __v_24];
+        record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_20: G = G::from_u64(0);
-        let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_16, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_16, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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);
@@ -46922,28 +47110,28 @@ fn aiur_fn_537(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_786] = { let __args: [G; IN_786] = [__v_4, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_4, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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_255] = { let __args: [G; IN_255] = [__v_33, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_33, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __ret: [G; OUT_537] = [__v_36, __v_37];
-        record.function_queries[537].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_542] = [__v_36, __v_37];
+        record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_538: usize = 2;
-const IN_538: usize = 2;
-const OUT_538: usize = 1;
-fn aiur_fn_538(
-  inp: [G; IN_538],
+const INPUT_SIZE_543: usize = 2;
+const IN_543: usize = 2;
+const OUT_543: usize = 1;
+fn aiur_fn_543(
+  inp: [G; IN_543],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_538], ExecError> {
+) -> Result<[G; OUT_543], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -46951,8 +47139,8 @@ fn aiur_fn_538(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_538] = [__v_3];
-        record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_543] = [__v_3];
+        record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -46960,14 +47148,14 @@ fn aiur_fn_538(
         match __v_3.as_canonical_u64() {
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_538] = [__v_4];
-            record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_543] = [__v_4];
+            record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_538] = [__v_4];
-            record.function_queries[538].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_543] = [__v_4];
+            record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -46979,96 +47167,96 @@ fn aiur_fn_538(
   })
 }
 
-const INPUT_SIZE_539: usize = 2;
-const IN_539: usize = 2;
-const OUT_539: usize = 1;
-fn aiur_fn_539(
-  inp: [G; IN_539],
+const INPUT_SIZE_544: usize = 2;
+const IN_544: usize = 2;
+const OUT_544: usize = 1;
+fn aiur_fn_544(
+  inp: [G; IN_544],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_539], ExecError> {
+) -> Result<[G; OUT_544], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_539] = [__v_1];
-        record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_544] = [__v_1];
+        record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_539] = [__v_0];
-        record.function_queries[539].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_544] = [__v_0];
+        record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_540: usize = 0;
-const IN_540: usize = 0;
-const OUT_540: usize = 2;
-fn aiur_fn_540(
-  inp: [G; IN_540],
+const INPUT_SIZE_545: usize = 0;
+const IN_545: usize = 0;
+const OUT_545: usize = 2;
+fn aiur_fn_545(
+  inp: [G; IN_545],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_540], ExecError> {
+) -> Result<[G; OUT_545], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(0);
     let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_540] = [__v_0, __v_1];
-    record.function_queries[540].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_545] = [__v_0, __v_1];
+    record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_541: usize = 0;
-const IN_541: usize = 0;
-const OUT_541: usize = 2;
-fn aiur_fn_541(
-  inp: [G; IN_541],
+const INPUT_SIZE_546: usize = 0;
+const IN_546: usize = 0;
+const OUT_546: usize = 2;
+fn aiur_fn_546(
+  inp: [G; IN_546],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_541], ExecError> {
+) -> Result<[G; OUT_546], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(1);
     let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_541] = [__v_0, __v_1];
-    record.function_queries[541].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_546] = [__v_0, __v_1];
+    record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_542: usize = 0;
-const IN_542: usize = 0;
-const OUT_542: usize = 2;
-fn aiur_fn_542(
-  inp: [G; IN_542],
+const INPUT_SIZE_547: usize = 0;
+const IN_547: usize = 0;
+const OUT_547: usize = 2;
+fn aiur_fn_547(
+  inp: [G; IN_547],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_542], ExecError> {
+) -> Result<[G; OUT_547], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = G::from_u64(2);
     let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_542] = [__v_0, __v_1];
-    record.function_queries[542].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_547] = [__v_0, __v_1];
+    record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_543: usize = 4;
-const IN_543: usize = 4;
-const OUT_543: usize = 2;
-fn aiur_fn_543(
-  inp: [G; IN_543],
+const INPUT_SIZE_548: usize = 4;
+const IN_548: usize = 4;
+const OUT_548: usize = 2;
+fn aiur_fn_548(
+  inp: [G; IN_548],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_543], ExecError> {
+) -> Result<[G; OUT_548], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47077,46 +47265,46 @@ fn aiur_fn_543(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_4: G = (__v_1 * __v_3);
-        let __ret: [G; OUT_543] = [__v_2, __v_4];
-        record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_548] = [__v_2, __v_4];
+        record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_543] = [__v_0, __v_1];
-        record.function_queries[543].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_548] = [__v_0, __v_1];
+        record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_544: usize = 1;
-const IN_544: usize = 1;
-const OUT_544: usize = 2;
-fn aiur_fn_544(
-  inp: [G; IN_544],
+const INPUT_SIZE_549: usize = 1;
+const IN_549: usize = 1;
+const OUT_549: usize = 2;
+fn aiur_fn_549(
+  inp: [G; IN_549],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_544], ExecError> {
+) -> Result<[G; OUT_549], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
-    let __ret: [G; OUT_544] = [__v_0, __v_1];
-    record.function_queries[544].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_549] = [__v_0, __v_1];
+    record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_545: usize = 2;
-const IN_545: usize = 2;
-const OUT_545: usize = 1;
-fn aiur_fn_545(
-  inp: [G; IN_545],
+const INPUT_SIZE_550: usize = 2;
+const IN_550: usize = 2;
+const OUT_550: usize = 1;
+fn aiur_fn_550(
+  inp: [G; IN_550],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_545], ExecError> {
+) -> Result<[G; OUT_550], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47186,51 +47374,51 @@ fn aiur_fn_545(
     let __v_63: G = __loaded[29];
     let __v_64: G = __loaded[30];
     let __v_65: G = __loaded[31];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_2, __v_3, __v_4, __v_5, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_66: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_6, __v_7, __v_8, __v_9, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_67: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_10, __v_11, __v_12, __v_13, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_14, __v_15, __v_16, __v_17, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_18, __v_19, __v_20, __v_21, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_70: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_22, __v_23, __v_24, __v_25, __v_54, __v_55, __v_56, __v_57]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_71: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_26, __v_27, __v_28, __v_29, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_72: G = __r_arr[0];
-    let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_30, __v_31, __v_32, __v_33, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
     let __v_73: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_72, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_72, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_74: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_71, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_71, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_75: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_70, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_70, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_76: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_69, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_69, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_77: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_68, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_68, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_78: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_67, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_67, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_79: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_66, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_66, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_80: G = __r_arr[0];
-    let __ret: [G; OUT_545] = [__v_80];
-    record.function_queries[545].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_550] = [__v_80];
+    record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_546: usize = 8;
-const IN_546: usize = 8;
-const OUT_546: usize = 1;
-fn aiur_fn_546(
-  inp: [G; IN_546],
+const INPUT_SIZE_551: usize = 8;
+const IN_551: usize = 8;
+const OUT_551: usize = 1;
+fn aiur_fn_551(
+  inp: [G; IN_551],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_546], ExecError> {
+) -> Result<[G; OUT_551], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47258,23 +47446,23 @@ fn aiur_fn_546(
     let __v_23: G = (__v_22 + __v_7);
     let __v_24: G = (__v_20 + __v_23);
     let __v_25: G = (__v_18 + __v_24);
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_16, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_16, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
-    let __ret: [G; OUT_546] = [__v_26];
-    record.function_queries[546].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_551] = [__v_26];
+    record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_547: usize = 2;
-const IN_547: usize = 2;
-const OUT_547: usize = 1;
-fn aiur_fn_547(
-  inp: [G; IN_547],
+const INPUT_SIZE_552: usize = 2;
+const IN_552: usize = 2;
+const OUT_552: usize = 1;
+fn aiur_fn_552(
+  inp: [G; IN_552],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_547], ExecError> {
+) -> Result<[G; OUT_552], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47286,8 +47474,8 @@ fn aiur_fn_547(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_547] = [__v_6];
-        record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_552] = [__v_6];
+        record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -47297,15 +47485,15 @@ fn aiur_fn_547(
           1u64 => {
             let __v_7: G = G::from_u64(1);
             let __v_8: G = (__v_7 + __v_4);
-            let __ret: [G; OUT_547] = [__v_8];
-            record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_552] = [__v_8];
+            record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_547] = [__v_7];
-            record.function_queries[547].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_552] = [__v_7];
+            record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47317,15 +47505,15 @@ fn aiur_fn_547(
   })
 }
 
-const INPUT_SIZE_548: usize = 3;
-const IN_548: usize = 3;
-const OUT_548: usize = 2;
-fn aiur_fn_548(
-  inp: [G; IN_548],
+const INPUT_SIZE_553: usize = 3;
+const IN_553: usize = 3;
+const OUT_553: usize = 2;
+fn aiur_fn_553(
+  inp: [G; IN_553],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_548], ExecError> {
+) -> Result<[G; OUT_553], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47334,37 +47522,37 @@ fn aiur_fn_548(
     let __v_3: G = __r_arr[0];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __ret: [G; OUT_548] = [__v_4, __v_5];
-        record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_553] = [__v_4, __v_5];
+        record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           0u64 => {
             match __v_5.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i); } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => aiur_fn_550(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
-                let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
                 let __v_7: G = __r_arr[0];
                 let __v_8: G = __r_arr[1];
-                let __ret: [G; OUT_548] = [__v_7, __v_8];
-                record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_553] = [__v_7, __v_8];
+                record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
                 let __v_7: G = __r_arr[1];
-                let __ret: [G; OUT_548] = [__v_6, __v_7];
-                record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_553] = [__v_6, __v_7];
+                record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -47372,19 +47560,19 @@ fn aiur_fn_548(
           _ => {
             match __v_5.as_canonical_u64() {
               0u64 => {
-                let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
                 let __v_7: G = __r_arr[1];
-                let __ret: [G; OUT_548] = [__v_6, __v_7];
-                record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_553] = [__v_6, __v_7];
+                record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
                 let __v_6: G = __r_arr[0];
                 let __v_7: G = G::from_u64(0);
-                let __ret: [G; OUT_548] = [__v_6, __v_7];
-                record.function_queries[548].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_553] = [__v_6, __v_7];
+                record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -47395,15 +47583,15 @@ fn aiur_fn_548(
   })
 }
 
-const INPUT_SIZE_549: usize = 2;
-const IN_549: usize = 2;
-const OUT_549: usize = 1;
-fn aiur_fn_549(
-  inp: [G; IN_549],
+const INPUT_SIZE_554: usize = 2;
+const IN_554: usize = 2;
+const OUT_554: usize = 1;
+fn aiur_fn_554(
+  inp: [G; IN_554],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_549], ExecError> {
+) -> Result<[G; OUT_554], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47420,14 +47608,14 @@ fn aiur_fn_549(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47440,21 +47628,21 @@ fn aiur_fn_549(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47467,31 +47655,31 @@ fn aiur_fn_549(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_549] = [__v_10];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_10];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47504,37 +47692,37 @@ fn aiur_fn_549(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_549] = [__v_10];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_10];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -47549,16 +47737,16 @@ fn aiur_fn_549(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           4u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_549] = [__v_8];
-            record.function_queries[549].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_554] = [__v_8];
+            record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47570,15 +47758,15 @@ fn aiur_fn_549(
   })
 }
 
-const INPUT_SIZE_550: usize = 2;
-const IN_550: usize = 2;
-const OUT_550: usize = 1;
-fn aiur_fn_550(
-  inp: [G; IN_550],
+const INPUT_SIZE_555: usize = 2;
+const IN_555: usize = 2;
+const OUT_555: usize = 1;
+fn aiur_fn_555(
+  inp: [G; IN_555],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_550], ExecError> {
+) -> Result<[G; OUT_555], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47595,14 +47783,14 @@ fn aiur_fn_550(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_550] = [__v_8];
-            record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_555] = [__v_8];
+            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_550] = [__v_8];
-            record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_555] = [__v_8];
+            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47615,19 +47803,19 @@ fn aiur_fn_550(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_550] = [__v_8];
-            record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_555] = [__v_8];
+            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i); } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => aiur_fn_550(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_550] = [__v_10];
-            record.function_queries[550].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_555] = [__v_10];
+            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -47642,15 +47830,15 @@ fn aiur_fn_550(
   })
 }
 
-const INPUT_SIZE_551: usize = 4;
-const IN_551: usize = 4;
-const OUT_551: usize = 1;
-fn aiur_fn_551(
-  inp: [G; IN_551],
+const INPUT_SIZE_556: usize = 4;
+const IN_556: usize = 4;
+const OUT_556: usize = 1;
+fn aiur_fn_556(
+  inp: [G; IN_556],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_551], ExecError> {
+) -> Result<[G; OUT_556], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47660,16 +47848,16 @@ fn aiur_fn_551(
       0u64 => {
         match __v_2.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[552].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[552].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[552].bump_multiplicity(__i); } let __ret: [G; OUT_552] = unsafe { *(record.function_queries[552].output_at(__i).as_ptr() as *const [G; OUT_552]) }; __ret }, _ => aiur_fn_552(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[557].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[557].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => aiur_fn_557(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_551] = [__v_4];
-            record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_556] = [__v_4];
+            record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
-            let __ret: [G; OUT_551] = [__v_4];
-            record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_556] = [__v_4];
+            record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -47681,15 +47869,15 @@ fn aiur_fn_551(
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_4: G = G::from_u64(2);
-            let __ret: [G; OUT_551] = [__v_4];
-            record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_556] = [__v_4];
+            record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
             let __v_4: G = __r_arr[0];
-            let __ret: [G; OUT_551] = [__v_4];
-            record.function_queries[551].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_556] = [__v_4];
+            record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -47704,54 +47892,54 @@ fn aiur_fn_551(
   })
 }
 
-const INPUT_SIZE_552: usize = 2;
-const IN_552: usize = 2;
-const OUT_552: usize = 1;
-fn aiur_fn_552(
-  inp: [G; IN_552],
+const INPUT_SIZE_557: usize = 2;
+const IN_557: usize = 2;
+const OUT_557: usize = 1;
+fn aiur_fn_557(
+  inp: [G; IN_557],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_552], ExecError> {
+) -> Result<[G; OUT_557], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_122] = { let __args: [G; IN_122] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[122].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[122].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[122].bump_multiplicity(__i); } let __ret: [G; OUT_122] = unsafe { *(record.function_queries[122].output_at(__i).as_ptr() as *const [G; OUT_122]) }; __ret }, _ => aiur_fn_122(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[127].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[127].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[127].bump_multiplicity(__i); } let __ret: [G; OUT_127] = unsafe { *(record.function_queries[127].output_at(__i).as_ptr() as *const [G; OUT_127]) }; __ret }, _ => aiur_fn_127(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
     match __v_6.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[553].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => aiur_fn_553(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[558].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => aiur_fn_558(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_552] = [__v_7];
-        record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_557] = [__v_7];
+        record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_552] = [__v_6];
-        record.function_queries[552].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_557] = [__v_6];
+        record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_553: usize = 2;
-const IN_553: usize = 2;
-const OUT_553: usize = 1;
-fn aiur_fn_553(
-  inp: [G; IN_553],
+const INPUT_SIZE_558: usize = 2;
+const IN_558: usize = 2;
+const OUT_558: usize = 1;
+fn aiur_fn_558(
+  inp: [G; IN_558],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_553], ExecError> {
+) -> Result<[G; OUT_558], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47769,8 +47957,8 @@ fn aiur_fn_553(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_553] = [__v_12];
-        record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_558] = [__v_12];
+        record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -47787,14 +47975,14 @@ fn aiur_fn_553(
         let __v_21: G = __loaded[9];
         match __v_12.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[553].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => aiur_fn_553(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[558].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => aiur_fn_558(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
-            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__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; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__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; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[559].bump_multiplicity(__i); } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
-            let __ret: [G; OUT_553] = [__v_24];
-            record.function_queries[553].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_558] = [__v_24];
+            record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -47809,15 +47997,15 @@ fn aiur_fn_553(
   })
 }
 
-const INPUT_SIZE_554: usize = 16;
-const IN_554: usize = 16;
-const OUT_554: usize = 1;
-fn aiur_fn_554(
-  inp: [G; IN_554],
+const INPUT_SIZE_559: usize = 16;
+const IN_559: usize = 16;
+const OUT_559: usize = 1;
+fn aiur_fn_559(
+  inp: [G; IN_559],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_554], ExecError> {
+) -> Result<[G; OUT_559], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47835,51 +48023,51 @@ fn aiur_fn_554(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_7, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_7, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_6, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_6, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_5, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_20: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_21: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_22: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_22, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_24: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_21, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_19, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_19, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_27: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_18, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_18, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_17, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_16, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_16, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
-    let __ret: [G; OUT_554] = [__v_30];
-    record.function_queries[554].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_559] = [__v_30];
+    record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_555: usize = 2;
-const IN_555: usize = 2;
-const OUT_555: usize = 1;
-fn aiur_fn_555(
-  inp: [G; IN_555],
+const INPUT_SIZE_560: usize = 2;
+const IN_560: usize = 2;
+const OUT_560: usize = 1;
+fn aiur_fn_560(
+  inp: [G; IN_560],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_555], ExecError> {
+) -> Result<[G; OUT_560], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47896,14 +48084,14 @@ fn aiur_fn_555(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_555] = [__v_8];
-            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_560] = [__v_8];
+            record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_555] = [__v_8];
-            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_560] = [__v_8];
+            record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -47916,19 +48104,19 @@ fn aiur_fn_555(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(2);
-            let __ret: [G; OUT_555] = [__v_8];
-            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_560] = [__v_8];
+            record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[539].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[539].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[539].bump_multiplicity(__i); } let __ret: [G; OUT_539] = unsafe { *(record.function_queries[539].output_at(__i).as_ptr() as *const [G; OUT_539]) }; __ret }, _ => aiur_fn_539(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_555] = [__v_10];
-            record.function_queries[555].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_560] = [__v_10];
+            record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -47943,15 +48131,15 @@ fn aiur_fn_555(
   })
 }
 
-const INPUT_SIZE_556: usize = 3;
-const IN_556: usize = 3;
-const OUT_556: usize = 2;
-fn aiur_fn_556(
-  inp: [G; IN_556],
+const INPUT_SIZE_561: usize = 3;
+const IN_561: usize = 3;
+const OUT_561: usize = 2;
+fn aiur_fn_561(
+  inp: [G; IN_561],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_556], ExecError> {
+) -> Result<[G; OUT_561], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -47959,11 +48147,11 @@ fn aiur_fn_556(
     let __v_3: G = (__v_0 - __v_1);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = __r_arr[1];
-        let __ret: [G; OUT_556] = [__v_4, __v_5];
-        record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_561] = [__v_4, __v_5];
+        record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -47977,26 +48165,26 @@ fn aiur_fn_556(
         let __v_9: G = __loaded[1];
         let __v_10: G = __loaded[2];
         let __v_11: G = __loaded[3];
-        let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[557].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[557].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[557].bump_multiplicity(__i); } let __ret: [G; OUT_557] = unsafe { *(record.function_queries[557].output_at(__i).as_ptr() as *const [G; OUT_557]) }; __ret }, _ => aiur_fn_557(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[562].bump_multiplicity(__i); } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
         let __v_13: G = __r_arr[1];
-        let __ret: [G; OUT_556] = [__v_12, __v_13];
-        record.function_queries[556].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_561] = [__v_12, __v_13];
+        record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_557: usize = 9;
-const IN_557: usize = 9;
-const OUT_557: usize = 2;
-fn aiur_fn_557(
-  inp: [G; IN_557],
+const INPUT_SIZE_562: usize = 9;
+const IN_562: usize = 9;
+const OUT_562: usize = 2;
+fn aiur_fn_562(
+  inp: [G; IN_562],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_557], ExecError> {
+) -> Result<[G; OUT_562], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48011,21 +48199,21 @@ fn aiur_fn_557(
       0u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_10, __v_11];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_10, __v_11];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48033,29 +48221,29 @@ fn aiur_fn_557(
       1u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[554].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[554].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[554].bump_multiplicity(__i); } let __ret: [G; OUT_554] = unsafe { *(record.function_queries[554].output_at(__i).as_ptr() as *const [G; OUT_554]) }; __ret }, _ => aiur_fn_554(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_10, __v_11];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_10, __v_11];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48063,43 +48251,43 @@ fn aiur_fn_557(
       2u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[550].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[550].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[550].bump_multiplicity(__i); } let __ret: [G; OUT_550] = unsafe { *(record.function_queries[550].output_at(__i).as_ptr() as *const [G; OUT_550]) }; __ret }, _ => aiur_fn_550(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[555].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[555].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[555].bump_multiplicity(__i); } let __ret: [G; OUT_555] = unsafe { *(record.function_queries[555].output_at(__i).as_ptr() as *const [G; OUT_555]) }; __ret }, _ => aiur_fn_555(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[553].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => aiur_fn_553(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_14, __v_15];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_14, __v_15];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48107,49 +48295,49 @@ fn aiur_fn_557(
       3u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_13, __v_14];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_13, __v_14];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48157,57 +48345,57 @@ fn aiur_fn_557(
       4u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_13, __v_14];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_13, __v_14];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48215,65 +48403,65 @@ fn aiur_fn_557(
       5u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_13, __v_14];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_13, __v_14];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48281,79 +48469,79 @@ fn aiur_fn_557(
       6u64 => {
         match __v_4.as_canonical_u64() {
           0u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           4u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           5u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           6u64 => {
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_17, __v_18];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_17, __v_18];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48361,29 +48549,29 @@ fn aiur_fn_557(
       7u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           7u64 => {
-            let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[551].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[551].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[551].bump_multiplicity(__i); } let __ret: [G; OUT_551] = unsafe { *(record.function_queries[551].output_at(__i).as_ptr() as *const [G; OUT_551]) }; __ret }, _ => aiur_fn_551(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_10, __v_11];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_10, __v_11];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48391,33 +48579,33 @@ fn aiur_fn_557(
       8u64 => {
         match __v_4.as_canonical_u64() {
           8u64 => {
-            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[553].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[553].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[553].bump_multiplicity(__i); } let __ret: [G; OUT_553] = unsafe { *(record.function_queries[553].output_at(__i).as_ptr() as *const [G; OUT_553]) }; __ret }, _ => aiur_fn_553(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
             let __v_15: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_18, __v_19];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_18, __v_19];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
             let __v_10: G = __r_arr[1];
-            let __ret: [G; OUT_557] = [__v_9, __v_10];
-            record.function_queries[557].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_562] = [__v_9, __v_10];
+            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48429,15 +48617,15 @@ fn aiur_fn_557(
   })
 }
 
-const INPUT_SIZE_558: usize = 7;
-const IN_558: usize = 7;
-const OUT_558: usize = 2;
-fn aiur_fn_558(
-  inp: [G; IN_558],
+const INPUT_SIZE_563: usize = 7;
+const IN_563: usize = 7;
+const OUT_563: usize = 2;
+fn aiur_fn_563(
+  inp: [G; IN_563],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_558], ExecError> {
+) -> Result<[G; OUT_563], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48450,19 +48638,19 @@ fn aiur_fn_558(
       _ => {
         match __v_3.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             let __v_9: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __ret: [G; OUT_558] = [__v_12, __v_13];
-            record.function_queries[558].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_563] = [__v_12, __v_13];
+            record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48471,15 +48659,15 @@ fn aiur_fn_558(
   })
 }
 
-const INPUT_SIZE_559: usize = 3;
-const IN_559: usize = 3;
-const OUT_559: usize = 2;
-fn aiur_fn_559(
-  inp: [G; IN_559],
+const INPUT_SIZE_564: usize = 3;
+const IN_564: usize = 3;
+const OUT_564: usize = 2;
+fn aiur_fn_564(
+  inp: [G; IN_564],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_559], ExecError> {
+) -> Result<[G; OUT_564], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48500,19 +48688,19 @@ fn aiur_fn_559(
         let __v_12: G = __loaded[4];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_559] = [__v_13, __v_14];
-            record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_564] = [__v_13, __v_14];
+            record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = []; let __cu = unconstrained; let __hit = record.function_queries[540].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[540].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[540].bump_multiplicity(__i); } let __ret: [G; OUT_540] = unsafe { *(record.function_queries[540].output_at(__i).as_ptr() as *const [G; OUT_540]) }; __ret }, _ => aiur_fn_540(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = []; let __cu = unconstrained; let __hit = record.function_queries[545].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[545].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[545].bump_multiplicity(__i); } let __ret: [G; OUT_545] = unsafe { *(record.function_queries[545].output_at(__i).as_ptr() as *const [G; OUT_545]) }; __ret }, _ => aiur_fn_545(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_559] = [__v_13, __v_14];
-            record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_564] = [__v_13, __v_14];
+            record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48526,25 +48714,25 @@ fn aiur_fn_559(
         let __v_12: G = __loaded[4];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = []; let __cu = unconstrained; let __hit = record.function_queries[542].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[542].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[542].bump_multiplicity(__i); } let __ret: [G; OUT_542] = unsafe { *(record.function_queries[542].output_at(__i).as_ptr() as *const [G; OUT_542]) }; __ret }, _ => aiur_fn_542(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = []; let __cu = unconstrained; let __hit = record.function_queries[547].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[547].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[547].bump_multiplicity(__i); } let __ret: [G; OUT_547] = unsafe { *(record.function_queries[547].output_at(__i).as_ptr() as *const [G; OUT_547]) }; __ret }, _ => aiur_fn_547(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __ret: [G; OUT_559] = [__v_13, __v_14];
-            record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_564] = [__v_13, __v_14];
+            record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[558].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[558].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[558].bump_multiplicity(__i); } let __ret: [G; OUT_558] = unsafe { *(record.function_queries[558].output_at(__i).as_ptr() as *const [G; OUT_558]) }; __ret }, _ => aiur_fn_558(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[563].bump_multiplicity(__i); } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = __r_arr[1];
-            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[559].bump_multiplicity(__i); } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[564].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i); } let __ret: [G; OUT_564] = unsafe { *(record.function_queries[564].output_at(__i).as_ptr() as *const [G; OUT_564]) }; __ret }, _ => aiur_fn_564(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
             let __v_18: G = __r_arr[1];
-            let __ret: [G; OUT_559] = [__v_17, __v_18];
-            record.function_queries[559].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_564] = [__v_17, __v_18];
+            record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -48559,15 +48747,15 @@ fn aiur_fn_559(
   })
 }
 
-const INPUT_SIZE_560: usize = 12;
-const IN_560: usize = 12;
-const OUT_560: usize = 1;
-fn aiur_fn_560(
-  inp: [G; IN_560],
+const INPUT_SIZE_565: usize = 12;
+const IN_565: usize = 12;
+const OUT_565: usize = 1;
+fn aiur_fn_565(
+  inp: [G; IN_565],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_560], ExecError> {
+) -> Result<[G; OUT_565], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48584,50 +48772,50 @@ fn aiur_fn_560(
     match __v_0.as_canonical_u64() {
       1u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_12: G = G::from_u64(1);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_12: G = G::from_u64(2);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_12: G = G::from_u64(3);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_12: G = G::from_u64(4);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_12: G = G::from_u64(5);
-        let __ret: [G; OUT_560] = [__v_12];
-        record.function_queries[560].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_565] = [__v_12];
+        record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -48637,15 +48825,15 @@ fn aiur_fn_560(
   })
 }
 
-const INPUT_SIZE_561: usize = 25;
-const IN_561: usize = 25;
-const OUT_561: usize = 2;
-fn aiur_fn_561(
-  inp: [G; IN_561],
+const INPUT_SIZE_566: usize = 25;
+const IN_566: usize = 25;
+const OUT_566: usize = 2;
+fn aiur_fn_566(
+  inp: [G; IN_566],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_561], ExecError> {
+) -> Result<[G; OUT_566], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48672,42 +48860,42 @@ fn aiur_fn_561(
     let __v_22: G = inp[22];
     let __v_23: G = inp[23];
     let __v_24: G = inp[24];
-    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
-    let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__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; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__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; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
     let __v_26: G = __r_arr[0];
-    let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
     let __v_27: G = __r_arr[0];
     match __v_27.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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; let __hit = record.function_queries[562].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[562].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[562].bump_multiplicity(__i); } let __ret: [G; OUT_562] = unsafe { *(record.function_queries[562].output_at(__i).as_ptr() as *const [G; OUT_562]) }; __ret }, _ => aiur_fn_562(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __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; let __hit = record.function_queries[567].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[567].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[567].bump_multiplicity(__i); } let __ret: [G; OUT_567] = unsafe { *(record.function_queries[567].output_at(__i).as_ptr() as *const [G; OUT_567]) }; __ret }, _ => aiur_fn_567(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_561] = [__v_28, __v_29];
-        record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_566] = [__v_28, __v_29];
+        record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_561] = [__v_28, __v_29];
-        record.function_queries[561].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_566] = [__v_28, __v_29];
+        record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_562: usize = 25;
-const IN_562: usize = 25;
-const OUT_562: usize = 2;
-fn aiur_fn_562(
-  inp: [G; IN_562],
+const INPUT_SIZE_567: usize = 25;
+const IN_567: usize = 25;
+const OUT_567: usize = 2;
+fn aiur_fn_567(
+  inp: [G; IN_567],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_562], ExecError> {
+) -> Result<[G; OUT_567], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48738,33 +48926,33 @@ fn aiur_fn_562(
       1u64 => {
         match __v_12.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_3, __v_15, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_30: G = __r_arr[0];
             let __v_31: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_26, __v_27, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
             let __v_35: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_34, __v_35];
-            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_567] = [__v_34, __v_35];
+            record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_25, __v_26];
-            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_567] = [__v_25, __v_26];
+            record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48772,75 +48960,75 @@ fn aiur_fn_562(
       5u64 => {
         match __v_12.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_32, __v_33, __v_35, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_29, __v_30, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_26, __v_27, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_43: G = __r_arr[0];
             match __v_43.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
                 let __v_44: G = __r_arr[0];
                 let __v_45: G = __r_arr[1];
                 let __v_46: G = G::from_u64(0);
-                let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[563].bump_multiplicity(__i); } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_8, __v_19, __v_20, __v_5, __v_24, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i); } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } };
                 let __v_47: G = __r_arr[0];
                 let __v_48: G = __r_arr[1];
-                let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_44, __v_45, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
                 let __v_50: G = __r_arr[1];
-                let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_41, __v_42, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
                 let __v_52: G = __r_arr[1];
-                let __ret: [G; OUT_562] = [__v_51, __v_52];
-                record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_567] = [__v_51, __v_52];
+                record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
                 let __v_44: G = __r_arr[0];
                 let __v_45: G = __r_arr[1];
-                let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_41, __v_42, __v_44, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
                 let __v_46: G = __r_arr[0];
                 let __v_47: G = __r_arr[1];
-                let __ret: [G; OUT_562] = [__v_46, __v_47];
-                record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_567] = [__v_46, __v_47];
+                record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_25, __v_26];
-            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_567] = [__v_25, __v_26];
+            record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -48848,98 +49036,98 @@ fn aiur_fn_562(
       7u64 => {
         match __v_12.as_canonical_u64() {
           7u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_38: G = __r_arr[0];
             let __v_39: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_8, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_8, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_40: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_40]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[559].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[559].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[559].bump_multiplicity(__i); } let __ret: [G; OUT_559] = unsafe { *(record.function_queries[559].output_at(__i).as_ptr() as *const [G; OUT_559]) }; __ret }, _ => aiur_fn_559(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_7, __v_19, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[564].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i); } let __ret: [G; OUT_564] = unsafe { *(record.function_queries[564].output_at(__i).as_ptr() as *const [G; OUT_564]) }; __ret }, _ => aiur_fn_564(__args, record, io_buffer, __cu)? } };
             let __v_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_47: G = __r_arr[0];
             let __v_48: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_41, __v_42, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
             let __v_50: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_38, __v_39, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
             let __v_52: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_35, __v_36, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_32, __v_33, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
             let __v_56: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_29, __v_30, __v_55, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_57: G = __r_arr[0];
             let __v_58: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_26, __v_27, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_59: G = __r_arr[0];
             let __v_60: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_59, __v_60];
-            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_567] = [__v_59, __v_60];
+            record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
             let __v_26: G = __r_arr[1];
-            let __ret: [G; OUT_562] = [__v_25, __v_26];
-            record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_567] = [__v_25, __v_26];
+            record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = __r_arr[1];
-        let __ret: [G; OUT_562] = [__v_25, __v_26];
-        record.function_queries[562].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_567] = [__v_25, __v_26];
+        record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_563: usize = 7;
-const IN_563: usize = 7;
-const OUT_563: usize = 2;
-fn aiur_fn_563(
-  inp: [G; IN_563],
+const INPUT_SIZE_568: usize = 7;
+const IN_568: usize = 7;
+const OUT_568: usize = 2;
+fn aiur_fn_568(
+  inp: [G; IN_568],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_563], ExecError> {
+) -> Result<[G; OUT_568], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -48951,15 +49139,15 @@ fn aiur_fn_563(
     let __v_7: G = (__v_4 - __v_6);
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = []; let __cu = unconstrained; let __hit = record.function_queries[541].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[541].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[541].bump_multiplicity(__i); } let __ret: [G; OUT_541] = unsafe { *(record.function_queries[541].output_at(__i).as_ptr() as *const [G; OUT_541]) }; __ret }, _ => aiur_fn_541(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = []; let __cu = unconstrained; let __hit = record.function_queries[546].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[546].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[546].bump_multiplicity(__i); } let __ret: [G; OUT_546] = unsafe { *(record.function_queries[546].output_at(__i).as_ptr() as *const [G; OUT_546]) }; __ret }, _ => aiur_fn_546(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_563] = [__v_8, __v_9];
-        record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_568] = [__v_8, __v_9];
+        record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -48974,7 +49162,7 @@ fn aiur_fn_563(
         let __v_18: G = __loaded[9];
         let __v_19: G = __loaded[10];
         let __v_20: G = __loaded[11];
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_22: G = __loaded[0];
@@ -48989,34 +49177,34 @@ fn aiur_fn_563(
         let __v_31: G = __loaded[9];
         let __v_32: G = __loaded[10];
         let __v_33: G = __loaded[11];
-        let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[564].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[564].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[564].bump_multiplicity(__i); } let __ret: [G; OUT_564] = unsafe { *(record.function_queries[564].output_at(__i).as_ptr() as *const [G; OUT_564]) }; __ret }, _ => aiur_fn_564(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } };
         let __v_34: G = __r_arr[0];
         let __v_35: G = __r_arr[1];
         let __v_36: G = G::from_u64(1);
         let __v_37: G = (__v_6 + __v_36);
-        let __r_arr: [G; OUT_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[563].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[563].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[563].bump_multiplicity(__i); } let __ret: [G; OUT_563] = unsafe { *(record.function_queries[563].output_at(__i).as_ptr() as *const [G; OUT_563]) }; __ret }, _ => aiur_fn_563(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[568].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[568].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[568].bump_multiplicity(__i); } let __ret: [G; OUT_568] = unsafe { *(record.function_queries[568].output_at(__i).as_ptr() as *const [G; OUT_568]) }; __ret }, _ => aiur_fn_568(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
-        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_34, __v_35, __v_38, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
         let __v_41: G = __r_arr[1];
-        let __ret: [G; OUT_563] = [__v_40, __v_41];
-        record.function_queries[563].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_568] = [__v_40, __v_41];
+        record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_564: usize = 25;
-const IN_564: usize = 25;
-const OUT_564: usize = 2;
-fn aiur_fn_564(
-  inp: [G; IN_564],
+const INPUT_SIZE_569: usize = 25;
+const IN_569: usize = 25;
+const OUT_569: usize = 2;
+fn aiur_fn_569(
+  inp: [G; IN_569],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_564], ExecError> {
+) -> Result<[G; OUT_569], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49047,94 +49235,94 @@ fn aiur_fn_564(
       6u64 => {
         match __v_12.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_1, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_25]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
             let __v_30: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_6, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_31: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_31]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_32: G = __r_arr[0];
             let __v_33: G = __r_arr[1];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_7, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_34]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
             let __v_36: G = __r_arr[1];
-            let __r_arr: [G; OUT_556] = { let __args: [G; IN_556] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[556].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[556].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[556].bump_multiplicity(__i); } let __ret: [G; OUT_556] = unsafe { *(record.function_queries[556].output_at(__i).as_ptr() as *const [G; OUT_556]) }; __ret }, _ => aiur_fn_556(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_2, __v_14, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
             let __v_38: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
             let __v_40: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_32, __v_33, __v_39, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_41: G = __r_arr[0];
             let __v_42: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_29, __v_30, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_43: G = __r_arr[0];
             let __v_44: G = __r_arr[1];
-            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_26, __v_27, __v_43, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[548].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[548].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[548].bump_multiplicity(__i); } let __ret: [G; OUT_548] = unsafe { *(record.function_queries[548].output_at(__i).as_ptr() as *const [G; OUT_548]) }; __ret }, _ => aiur_fn_548(__args, record, io_buffer, __cu)? } };
             let __v_45: G = __r_arr[0];
             let __v_46: G = __r_arr[1];
-            let __ret: [G; OUT_564] = [__v_45, __v_46];
-            record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_569] = [__v_45, __v_46];
+            record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__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; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__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; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
-            let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
             let __v_29: G = __r_arr[1];
-            let __ret: [G; OUT_564] = [__v_28, __v_29];
-            record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_569] = [__v_28, __v_29];
+            record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
-        let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__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; let __hit = record.function_queries[560].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[560].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[560].bump_multiplicity(__i); } let __ret: [G; OUT_560] = unsafe { *(record.function_queries[560].output_at(__i).as_ptr() as *const [G; OUT_560]) }; __ret }, _ => aiur_fn_560(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__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; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
         let __v_26: G = __r_arr[0];
-        let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[538].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[538].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[538].bump_multiplicity(__i); } let __ret: [G; OUT_538] = unsafe { *(record.function_queries[538].output_at(__i).as_ptr() as *const [G; OUT_538]) }; __ret }, _ => aiur_fn_538(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_25, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[543].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[543].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[543].bump_multiplicity(__i); } let __ret: [G; OUT_543] = unsafe { *(record.function_queries[543].output_at(__i).as_ptr() as *const [G; OUT_543]) }; __ret }, _ => aiur_fn_543(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[544].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[544].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[544].bump_multiplicity(__i); } let __ret: [G; OUT_544] = unsafe { *(record.function_queries[544].output_at(__i).as_ptr() as *const [G; OUT_544]) }; __ret }, _ => aiur_fn_544(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_27]; let __cu = unconstrained; let __hit = record.function_queries[549].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[549].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[549].bump_multiplicity(__i); } let __ret: [G; OUT_549] = unsafe { *(record.function_queries[549].output_at(__i).as_ptr() as *const [G; OUT_549]) }; __ret }, _ => aiur_fn_549(__args, record, io_buffer, __cu)? } };
         let __v_28: G = __r_arr[0];
         let __v_29: G = __r_arr[1];
-        let __ret: [G; OUT_564] = [__v_28, __v_29];
-        record.function_queries[564].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_569] = [__v_28, __v_29];
+        record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_565: usize = 3;
-const IN_565: usize = 3;
-const OUT_565: usize = 1;
-fn aiur_fn_565(
-  inp: [G; IN_565],
+const INPUT_SIZE_570: usize = 3;
+const IN_570: usize = 3;
+const OUT_570: usize = 1;
+fn aiur_fn_570(
+  inp: [G; IN_570],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_565], ExecError> {
+) -> Result<[G; OUT_570], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(4);
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__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];
@@ -49143,7 +49331,7 @@ fn aiur_fn_565(
     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_293] = { let __args: [G; IN_293] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__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];
@@ -49165,31 +49353,31 @@ fn aiur_fn_565(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_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; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
-    let __ret: [G; OUT_565] = [__v_34];
-    record.function_queries[565].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_570] = [__v_34];
+    record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_566: usize = 2;
-const IN_566: usize = 2;
-const OUT_566: usize = 12;
-fn aiur_fn_566(
-  inp: [G; IN_566],
+const INPUT_SIZE_571: usize = 2;
+const IN_571: usize = 2;
+const OUT_571: usize = 12;
+fn aiur_fn_571(
+  inp: [G; IN_571],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_566], ExecError> {
+) -> Result<[G; OUT_571], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -49204,25 +49392,25 @@ fn aiur_fn_566(
     let __v_13: G = __loaded[9];
     let __v_14: G = __loaded[10];
     let __v_15: G = __loaded[11];
-    let __ret: [G; OUT_566] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
-    record.function_queries[566].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_571] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15];
+    record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_567: usize = 2;
-const IN_567: usize = 2;
-const OUT_567: usize = 1;
-fn aiur_fn_567(
-  inp: [G; IN_567],
+const INPUT_SIZE_572: usize = 2;
+const IN_572: usize = 2;
+const OUT_572: usize = 1;
+fn aiur_fn_572(
+  inp: [G; IN_572],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_567], ExecError> {
+) -> Result<[G; OUT_572], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__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];
@@ -49237,53 +49425,53 @@ fn aiur_fn_567(
     let __v_13: G = __r_arr[11];
     match __v_2.as_canonical_u64() {
       5u64 => {
-        let __ret: [G; OUT_567] = [__v_7];
-        record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_572] = [__v_7];
+        record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_14: G = G::from_u64(0);
-        let __ret: [G; OUT_567] = [__v_14];
-        record.function_queries[567].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_572] = [__v_14];
+        record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_568: usize = 3;
-const IN_568: usize = 3;
-const OUT_568: usize = 1;
-fn aiur_fn_568(
-  inp: [G; IN_568],
+const INPUT_SIZE_573: usize = 3;
+const IN_573: usize = 3;
+const OUT_573: usize = 1;
+fn aiur_fn_573(
+  inp: [G; IN_573],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_568], ExecError> {
+) -> Result<[G; OUT_573], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __ret: [G; OUT_568] = [__v_5];
-    record.function_queries[568].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_573] = [__v_5];
+    record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_569: usize = 5;
-const IN_569: usize = 5;
-const OUT_569: usize = 1;
-fn aiur_fn_569(
-  inp: [G; IN_569],
+const INPUT_SIZE_574: usize = 5;
+const IN_574: usize = 5;
+const OUT_574: usize = 1;
+fn aiur_fn_574(
+  inp: [G; IN_574],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_569], ExecError> {
+) -> Result<[G; OUT_574], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49299,23 +49487,23 @@ fn aiur_fn_569(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_569] = [__v_10];
-        record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_574] = [__v_10];
+        record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i); } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__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_569] = { let __args: [G; IN_569] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_7, __v_1, __v_2, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_8, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_569] = [__v_14];
-        record.function_queries[569].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_574] = [__v_14];
+        record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -49325,15 +49513,15 @@ fn aiur_fn_569(
   })
 }
 
-const INPUT_SIZE_570: usize = 5;
-const IN_570: usize = 5;
-const OUT_570: usize = 2;
-fn aiur_fn_570(
-  inp: [G; IN_570],
+const INPUT_SIZE_575: usize = 5;
+const IN_575: usize = 5;
+const OUT_575: usize = 2;
+fn aiur_fn_575(
+  inp: [G; IN_575],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_570], ExecError> {
+) -> Result<[G; OUT_575], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49350,35 +49538,35 @@ fn aiur_fn_570(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_570] = [__v_10, __v_11];
-        record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_575] = [__v_10, __v_11];
+        record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i); } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[567].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[567].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[567].bump_multiplicity(__i); } let __ret: [G; OUT_567] = unsafe { *(record.function_queries[567].output_at(__i).as_ptr() as *const [G; OUT_567]) }; __ret }, _ => aiur_fn_567(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[572].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[572].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[572].bump_multiplicity(__i); } let __ret: [G; OUT_572] = unsafe { *(record.function_queries[572].output_at(__i).as_ptr() as *const [G; OUT_572]) }; __ret }, _ => aiur_fn_572(__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_571] = { let __args: [G; IN_571] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_2, __v_6, __v_10, __v_4, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__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_777] = { let __args: [G; IN_777] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_1, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_12, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_12, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_17: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_17.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_570] = [__v_16, __v_10];
-            record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_575] = [__v_16, __v_10];
+            record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_570] = [__v_16, __v_9];
-            record.function_queries[570].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_575] = [__v_16, __v_9];
+            record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -49390,15 +49578,15 @@ fn aiur_fn_570(
   })
 }
 
-const INPUT_SIZE_571: usize = 5;
-const IN_571: usize = 5;
-const OUT_571: usize = 1;
-fn aiur_fn_571(
-  inp: [G; IN_571],
+const INPUT_SIZE_576: usize = 5;
+const IN_576: usize = 5;
+const OUT_576: usize = 1;
+fn aiur_fn_576(
+  inp: [G; IN_576],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_571], ExecError> {
+) -> Result<[G; OUT_576], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49411,37 +49599,37 @@ fn aiur_fn_571(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_571] = [__v_8];
-        record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_576] = [__v_8];
+        record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[565].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[565].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[565].bump_multiplicity(__i); } let __ret: [G; OUT_565] = unsafe { *(record.function_queries[565].output_at(__i).as_ptr() as *const [G; OUT_565]) }; __ret }, _ => aiur_fn_565(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[570].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[570].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[570].bump_multiplicity(__i); } let __ret: [G; OUT_570] = unsafe { *(record.function_queries[570].output_at(__i).as_ptr() as *const [G; OUT_570]) }; __ret }, _ => aiur_fn_570(__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_571] = { let __args: [G; IN_571] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_1, __v_2, __v_3, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_571] = [__v_12];
-        record.function_queries[571].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_576] = [__v_12];
+        record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_572: usize = 3;
-const IN_572: usize = 3;
-const OUT_572: usize = 1;
-fn aiur_fn_572(
-  inp: [G; IN_572],
+const INPUT_SIZE_577: usize = 3;
+const IN_577: usize = 3;
+const OUT_577: usize = 1;
+fn aiur_fn_577(
+  inp: [G; IN_577],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_572], ExecError> {
+) -> Result<[G; OUT_577], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49452,26 +49640,26 @@ fn aiur_fn_572(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_573] = { let __args: [G; IN_573] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __ret: [G; OUT_572] = [__v_11];
-    record.function_queries[572].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_577] = [__v_11];
+    record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_573: usize = 4;
-const IN_573: usize = 4;
-const OUT_573: usize = 1;
-fn aiur_fn_573(
-  inp: [G; IN_573],
+const INPUT_SIZE_578: usize = 4;
+const IN_578: usize = 4;
+const OUT_578: usize = 1;
+fn aiur_fn_578(
+  inp: [G; IN_578],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_573], ExecError> {
+) -> Result<[G; OUT_578], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49479,33 +49667,33 @@ fn aiur_fn_573(
     let __v_3: G = inp[3];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_573] = [__v_0];
-        record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_578] = [__v_0];
+        record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_4: G = G::from_u64(0);
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[569].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[569].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[569].bump_multiplicity(__i); } let __ret: [G; OUT_569] = unsafe { *(record.function_queries[569].output_at(__i).as_ptr() as *const [G; OUT_569]) }; __ret }, _ => aiur_fn_569(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_1, __v_2, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_6, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[585].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => aiur_fn_585(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         match __v_8.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_573] = [__v_0];
-            record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_578] = [__v_0];
+            record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_9: G = G::from_u64(1);
             let __v_10: G = (__v_3 - __v_9);
-            let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_7, __v_1, __v_2, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
-            let __ret: [G; OUT_573] = [__v_11];
-            record.function_queries[573].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_578] = [__v_11];
+            record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -49514,15 +49702,15 @@ fn aiur_fn_573(
   })
 }
 
-const INPUT_SIZE_574: usize = 3;
-const IN_574: usize = 3;
-const OUT_574: usize = 1;
-fn aiur_fn_574(
-  inp: [G; IN_574],
+const INPUT_SIZE_579: usize = 3;
+const IN_579: usize = 3;
+const OUT_579: usize = 1;
+fn aiur_fn_579(
+  inp: [G; IN_579],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_574], ExecError> {
+) -> Result<[G; OUT_579], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49536,19 +49724,19 @@ fn aiur_fn_574(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_574] = [__v_8];
-        record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_579] = [__v_8];
+        record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[575].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[575].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[575].bump_multiplicity(__i); } let __ret: [G; OUT_575] = unsafe { *(record.function_queries[575].output_at(__i).as_ptr() as *const [G; OUT_575]) }; __ret }, _ => aiur_fn_575(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[574].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[574].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[574].bump_multiplicity(__i); } let __ret: [G; OUT_574] = unsafe { *(record.function_queries[574].output_at(__i).as_ptr() as *const [G; OUT_574]) }; __ret }, _ => aiur_fn_574(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_574] = [__v_8];
-        record.function_queries[574].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_579] = [__v_8];
+        record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -49558,28 +49746,28 @@ fn aiur_fn_574(
   })
 }
 
-const INPUT_SIZE_575: usize = 3;
-const IN_575: usize = 3;
-const OUT_575: usize = 1;
-fn aiur_fn_575(
-  inp: [G; IN_575],
+const INPUT_SIZE_580: usize = 3;
+const IN_580: usize = 3;
+const OUT_580: usize = 1;
+fn aiur_fn_580(
+  inp: [G; IN_580],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_575], ExecError> {
+) -> Result<[G; OUT_580], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_575] = [__v_6];
-        record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_580] = [__v_6];
+        record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -49588,32 +49776,32 @@ fn aiur_fn_575(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_575] = [__v_8];
-        record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_580] = [__v_8];
+        record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[581].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => aiur_fn_581(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_575] = [__v_5];
-        record.function_queries[575].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_580] = [__v_5];
+        record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_576: usize = 3;
-const IN_576: usize = 3;
-const OUT_576: usize = 1;
-fn aiur_fn_576(
-  inp: [G; IN_576],
+const INPUT_SIZE_581: usize = 3;
+const IN_581: usize = 3;
+const OUT_581: usize = 1;
+fn aiur_fn_581(
+  inp: [G; IN_581],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_576], ExecError> {
+) -> Result<[G; OUT_581], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49627,17 +49815,17 @@ fn aiur_fn_576(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_576] = [__v_8];
-        record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_581] = [__v_8];
+        record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[576].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[576].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[576].bump_multiplicity(__i); } let __ret: [G; OUT_576] = unsafe { *(record.function_queries[576].output_at(__i).as_ptr() as *const [G; OUT_576]) }; __ret }, _ => aiur_fn_576(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[581].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => aiur_fn_581(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_576] = [__v_7];
-        record.function_queries[576].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_581] = [__v_7];
+        record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -49647,15 +49835,15 @@ fn aiur_fn_576(
   })
 }
 
-const INPUT_SIZE_577: usize = 4;
-const IN_577: usize = 4;
-const OUT_577: usize = 1;
-fn aiur_fn_577(
-  inp: [G; IN_577],
+const INPUT_SIZE_582: usize = 4;
+const IN_582: usize = 4;
+const OUT_582: usize = 1;
+fn aiur_fn_582(
+  inp: [G; IN_582],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_577], ExecError> {
+) -> Result<[G; OUT_582], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49672,12 +49860,12 @@ fn aiur_fn_577(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_577] = [__v_11];
-        record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_582] = [__v_11];
+        record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__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];
@@ -49690,7 +49878,7 @@ fn aiur_fn_577(
         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_566] = { let __args: [G; IN_566] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_3, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__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];
@@ -49703,24 +49891,24 @@ fn aiur_fn_577(
         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_561] = { let __args: [G; IN_561] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_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; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
         let __v_31: G = __r_arr[0];
         let __v_32: G = __r_arr[1];
         match __v_31.as_canonical_u64() {
           0u64 => {
             let __v_33: G = G::from_u64(0);
             let __v_34: G = { let __values: [G; 3] = [__v_33, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_577] = [__v_34];
-            record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_582] = [__v_34];
+            record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_33: G = G::from_u64(0);
-            let __r_arr: [G; OUT_577] = { let __args: [G; IN_577] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[577].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[577].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[577].bump_multiplicity(__i); } let __ret: [G; OUT_577] = unsafe { *(record.function_queries[577].output_at(__i).as_ptr() as *const [G; OUT_577]) }; __ret }, _ => aiur_fn_577(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_577] = [__v_35];
-            record.function_queries[577].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_582] = [__v_35];
+            record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -49732,15 +49920,15 @@ fn aiur_fn_577(
   })
 }
 
-const INPUT_SIZE_578: usize = 3;
-const IN_578: usize = 3;
-const OUT_578: usize = 1;
-fn aiur_fn_578(
-  inp: [G; IN_578],
+const INPUT_SIZE_583: usize = 3;
+const IN_583: usize = 3;
+const OUT_583: usize = 1;
+fn aiur_fn_583(
+  inp: [G; IN_583],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_578], ExecError> {
+) -> Result<[G; OUT_583], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49754,8 +49942,8 @@ fn aiur_fn_578(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_578] = [__v_8];
-        record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_583] = [__v_8];
+        record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -49764,10 +49952,10 @@ fn aiur_fn_578(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_578] = [__v_11];
-        record.function_queries[578].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_583] = [__v_11];
+        record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -49777,15 +49965,15 @@ fn aiur_fn_578(
   })
 }
 
-const INPUT_SIZE_579: usize = 5;
-const IN_579: usize = 5;
-const OUT_579: usize = 1;
-fn aiur_fn_579(
-  inp: [G; IN_579],
+const INPUT_SIZE_584: usize = 5;
+const IN_584: usize = 5;
+const OUT_584: usize = 1;
+fn aiur_fn_584(
+  inp: [G; IN_584],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_579], ExecError> {
+) -> Result<[G; OUT_584], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49803,12 +49991,12 @@ fn aiur_fn_579(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_579] = [__v_12];
-        record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_584] = [__v_12];
+        record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__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];
@@ -49821,7 +50009,7 @@ fn aiur_fn_579(
         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_566] = { let __args: [G; IN_566] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[571].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[571].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[571].bump_multiplicity(__i); } let __ret: [G; OUT_571] = unsafe { *(record.function_queries[571].output_at(__i).as_ptr() as *const [G; OUT_571]) }; __ret }, _ => aiur_fn_571(__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];
@@ -49834,17 +50022,17 @@ fn aiur_fn_579(
         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_561] = { let __args: [G; IN_561] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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; let __hit = record.function_queries[561].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[561].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[561].bump_multiplicity(__i); } let __ret: [G; OUT_561] = unsafe { *(record.function_queries[561].output_at(__i).as_ptr() as *const [G; OUT_561]) }; __ret }, _ => aiur_fn_561(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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; let __hit = record.function_queries[566].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[566].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[566].bump_multiplicity(__i); } let __ret: [G; OUT_566] = unsafe { *(record.function_queries[566].output_at(__i).as_ptr() as *const [G; OUT_566]) }; __ret }, _ => aiur_fn_566(__args, record, io_buffer, __cu)? } };
         let __v_32: G = __r_arr[0];
         let __v_33: G = __r_arr[1];
         match __v_32.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } };
             let __v_35: G = __r_arr[0];
-            let __ret: [G; OUT_579] = [__v_35];
-            record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_584] = [__v_35];
+            record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -49854,11 +50042,11 @@ fn aiur_fn_579(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[579].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[579].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[579].bump_multiplicity(__i); } let __ret: [G; OUT_579] = unsafe { *(record.function_queries[579].output_at(__i).as_ptr() as *const [G; OUT_579]) }; __ret }, _ => aiur_fn_579(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_579] = [__v_41];
-            record.function_queries[579].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_584] = [__v_41];
+            record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -49870,15 +50058,15 @@ fn aiur_fn_579(
   })
 }
 
-const INPUT_SIZE_580: usize = 2;
-const IN_580: usize = 2;
-const OUT_580: usize = 1;
-fn aiur_fn_580(
-  inp: [G; IN_580],
+const INPUT_SIZE_585: usize = 2;
+const IN_585: usize = 2;
+const OUT_585: usize = 1;
+fn aiur_fn_585(
+  inp: [G; IN_585],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_580], ExecError> {
+) -> Result<[G; OUT_585], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -49895,14 +50083,14 @@ fn aiur_fn_580(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_580] = [__v_8];
-            record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_585] = [__v_8];
+            record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_580] = [__v_8];
-            record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_585] = [__v_8];
+            record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -49915,25 +50103,25 @@ fn aiur_fn_580(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_580] = [__v_8];
-            record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_585] = [__v_8];
+            record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               0u64 => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_580] = [__v_9];
-                record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_585] = [__v_9];
+                record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[580].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[580].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[580].bump_multiplicity(__i); } let __ret: [G; OUT_580] = unsafe { *(record.function_queries[580].output_at(__i).as_ptr() as *const [G; OUT_580]) }; __ret }, _ => aiur_fn_580(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[585].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => aiur_fn_585(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_580] = [__v_9];
-                record.function_queries[580].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_585] = [__v_9];
+                record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -49950,15 +50138,15 @@ fn aiur_fn_580(
   })
 }
 
-const INPUT_SIZE_581: usize = 1;
-const IN_581: usize = 1;
-const OUT_581: usize = 1;
-fn aiur_fn_581(
-  inp: [G; IN_581],
+const INPUT_SIZE_586: usize = 1;
+const IN_586: usize = 1;
+const OUT_586: usize = 1;
+fn aiur_fn_586(
+  inp: [G; IN_586],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_581], ExecError> {
+) -> Result<[G; OUT_586], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -49970,17 +50158,17 @@ fn aiur_fn_581(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_581] = [__v_6];
-        record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_586] = [__v_6];
+        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[581].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => aiur_fn_581(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_581] = [__v_5];
-        record.function_queries[581].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_586] = [__v_5];
+        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -49990,15 +50178,15 @@ fn aiur_fn_581(
   })
 }
 
-const INPUT_SIZE_582: usize = 1;
-const IN_582: usize = 1;
-const OUT_582: usize = 1;
-fn aiur_fn_582(
-  inp: [G; IN_582],
+const INPUT_SIZE_587: usize = 1;
+const IN_587: usize = 1;
+const OUT_587: usize = 1;
+fn aiur_fn_587(
+  inp: [G; IN_587],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_582], ExecError> {
+) -> Result<[G; OUT_587], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -50008,25 +50196,25 @@ fn aiur_fn_582(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_582] = [__v_4];
-        record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_587] = [__v_4];
+        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
             let __v_5: G = __r_arr[0];
-            let __ret: [G; OUT_582] = [__v_5];
-            record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_587] = [__v_5];
+            record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_582] = [__v_5];
-            record.function_queries[582].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_587] = [__v_5];
+            record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -50038,15 +50226,15 @@ fn aiur_fn_582(
   })
 }
 
-const INPUT_SIZE_583: usize = 2;
-const IN_583: usize = 2;
-const OUT_583: usize = 1;
-fn aiur_fn_583(
-  inp: [G; IN_583],
+const INPUT_SIZE_588: usize = 2;
+const IN_588: usize = 2;
+const OUT_588: usize = 1;
+fn aiur_fn_588(
+  inp: [G; IN_588],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_583], ExecError> {
+) -> Result<[G; OUT_588], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50103,26 +50291,26 @@ fn aiur_fn_583(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_583] = [__v_51];
-        record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_588] = [__v_51];
+        record.function_queries[588].finish(&inp[..], &__ret[..], !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_583] = { let __args: [G; IN_583] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
         let __v_51: G = __r_arr[0];
         match __v_3.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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_583] = [__v_53];
-            record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_588] = [__v_53];
+            record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_583] = [__v_51];
-            record.function_queries[583].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_588] = [__v_51];
+            record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -50134,15 +50322,15 @@ fn aiur_fn_583(
   })
 }
 
-const INPUT_SIZE_584: usize = 2;
-const IN_584: usize = 2;
-const OUT_584: usize = 1;
-fn aiur_fn_584(
-  inp: [G; IN_584],
+const INPUT_SIZE_589: usize = 2;
+const IN_589: usize = 2;
+const OUT_589: usize = 1;
+fn aiur_fn_589(
+  inp: [G; IN_589],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_584], ExecError> {
+) -> Result<[G; OUT_589], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50197,8 +50385,8 @@ fn aiur_fn_584(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_49: G = G::from_u64(0);
-        let __ret: [G; OUT_584] = [__v_49];
-        record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_589] = [__v_49];
+        record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -50224,15 +50412,15 @@ fn aiur_fn_584(
         match __v_49.as_canonical_u64() {
           1u64 => {
             let __v_50: G = G::from_u64(1);
-            let __ret: [G; OUT_584] = [__v_50];
-            record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_589] = [__v_50];
+            record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __ret: [G; OUT_584] = [__v_50];
-            record.function_queries[584].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_589] = [__v_50];
+            record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -50244,18 +50432,18 @@ fn aiur_fn_584(
   })
 }
 
-const INPUT_SIZE_585: usize = 1;
-const IN_585: usize = 1;
-const OUT_585: usize = 0;
-fn aiur_fn_585(
-  inp: [G; IN_585],
+const INPUT_SIZE_590: usize = 1;
+const IN_590: usize = 1;
+const OUT_590: usize = 0;
+fn aiur_fn_590(
+  inp: [G; IN_590],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_585], ExecError> {
+) -> Result<[G; OUT_590], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -50309,10 +50497,10 @@ fn aiur_fn_585(
         match __v_1.as_canonical_u64() {
           8u64 => {
             let __v_49: G = G::from_u64(1);
-            let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__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_584] = { let __args: [G; IN_584] = [__v_2, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[584].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[584].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[584].bump_multiplicity(__i); } let __ret: [G; OUT_584] = unsafe { *(record.function_queries[584].output_at(__i).as_ptr() as *const [G; OUT_584]) }; __ret }, _ => aiur_fn_584(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_2, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
             let __v_53: G = (__v_50 * __v_52);
             let __v_54: G = G::from_u64(0);
@@ -50320,20 +50508,20 @@ fn aiur_fn_585(
               return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_54.as_canonical_u64(), msg: Some("mutual block mixes a definition member with inductives".to_string()) });
             }
             let __v_55: G = G::from_u64(0);
-            let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_2, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[583].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[583].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[583].bump_multiplicity(__i); } let __ret: [G; OUT_583] = unsafe { *(record.function_queries[583].output_at(__i).as_ptr() as *const [G; OUT_583]) }; __ret }, _ => aiur_fn_583(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_2, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
             let __v_56: G = __r_arr[0];
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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 };
             match __v_59.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_585] = [];
-                record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_590] = [];
+                record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = [__v_2, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[300].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[300].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[300].bump_multiplicity(__i); } let __ret: [G; OUT_300] = unsafe { *(record.function_queries[300].output_at(__i).as_ptr() as *const [G; OUT_300]) }; __ret }, _ => aiur_fn_300(__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);
@@ -50341,34 +50529,34 @@ fn aiur_fn_585(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_56, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_775] = { let __args: [G; IN_775] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_56]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_573] = { let __args: [G; IN_573] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[573].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[573].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[573].bump_multiplicity(__i); } let __ret: [G; OUT_573] = unsafe { *(record.function_queries[573].output_at(__i).as_ptr() as *const [G; OUT_573]) }; __ret }, _ => aiur_fn_573(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_65, __v_60, __v_0, __v_68]; let __cu = unconstrained; let __hit = record.function_queries[578].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[578].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[578].bump_multiplicity(__i); } let __ret: [G; OUT_578] = unsafe { *(record.function_queries[578].output_at(__i).as_ptr() as *const [G; OUT_578]) }; __ret }, _ => aiur_fn_578(__args, record, io_buffer, __cu)? } };
                 let __v_69: G = __r_arr[0];
-                let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[582].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[582].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[582].bump_multiplicity(__i); } let __ret: [G; OUT_582] = unsafe { *(record.function_queries[582].output_at(__i).as_ptr() as *const [G; OUT_582]) }; __ret }, _ => aiur_fn_582(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__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_581] = { let __args: [G; IN_581] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[581].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[581].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[581].bump_multiplicity(__i); } let __ret: [G; OUT_581] = unsafe { *(record.function_queries[581].output_at(__i).as_ptr() as *const [G; OUT_581]) }; __ret }, _ => aiur_fn_581(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } };
                 let __v_72: G = __r_arr[0];
-                let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_72, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[339].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[339].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[339].bump_multiplicity(__i); } let __ret: [G; OUT_339] = unsafe { *(record.function_queries[339].output_at(__i).as_ptr() as *const [G; OUT_339]) }; __ret }, _ => aiur_fn_339(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_72, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[344].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[344].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[344].bump_multiplicity(__i); } let __ret: [G; OUT_344] = unsafe { *(record.function_queries[344].output_at(__i).as_ptr() as *const [G; OUT_344]) }; __ret }, _ => aiur_fn_344(__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()) });
                 }
-                let __ret: [G; OUT_585] = [];
-                record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_590] = [];
+                record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __ret: [G; OUT_585] = [];
-            record.function_queries[585].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_590] = [];
+            record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -50377,15 +50565,15 @@ fn aiur_fn_585(
   })
 }
 
-const INPUT_SIZE_586: usize = 12;
-const IN_586: usize = 12;
-const OUT_586: usize = 1;
-fn aiur_fn_586(
-  inp: [G; IN_586],
+const INPUT_SIZE_591: usize = 12;
+const IN_591: usize = 12;
+const OUT_591: usize = 1;
+fn aiur_fn_591(
+  inp: [G; IN_591],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_586], ExecError> {
+) -> Result<[G; OUT_591], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50401,56 +50589,56 @@ fn aiur_fn_586(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_586] = [__v_3];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_3];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_12: G = G::from_u64(0);
-            let __ret: [G; OUT_586] = [__v_12];
-            record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_591] = [__v_12];
+            record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_12: G = G::from_u64(1);
-            let __ret: [G; OUT_586] = [__v_12];
-            record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_591] = [__v_12];
+            record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       2u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_586] = [__v_12];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_12];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __ret: [G; OUT_586] = [__v_4];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_4];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_586] = [__v_12];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_12];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __ret: [G; OUT_586] = [__v_6];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_6];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __ret: [G; OUT_586] = [__v_8];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_8];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_586] = [__v_9];
-        record.function_queries[586].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_591] = [__v_9];
+        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -50460,15 +50648,15 @@ fn aiur_fn_586(
   })
 }
 
-const INPUT_SIZE_587: usize = 1;
-const IN_587: usize = 1;
-const OUT_587: usize = 1;
-fn aiur_fn_587(
-  inp: [G; IN_587],
+const INPUT_SIZE_592: usize = 1;
+const IN_592: usize = 1;
+const OUT_592: usize = 1;
+fn aiur_fn_592(
+  inp: [G; IN_592],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_587], ExecError> {
+) -> Result<[G; OUT_592], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -50479,18 +50667,18 @@ fn aiur_fn_587(
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_587] = [__v_5];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_5];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_587] = [__v_5];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_5];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
@@ -50506,67 +50694,67 @@ fn aiur_fn_587(
         let __v_16: G = __loaded[10];
         let __v_17: G = __loaded[11];
         let __v_18: G = G::from_u64(1);
-        let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = (__v_18 - __v_19);
-        let __ret: [G; OUT_587] = [__v_20];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_20];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 * __v_6);
-        let __ret: [G; OUT_587] = [__v_7];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_7];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 * __v_6);
-        let __ret: [G; OUT_587] = [__v_7];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_7];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = (__v_5 * __v_6);
-        let __ret: [G; OUT_587] = [__v_7];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_7];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = (__v_6 * __v_7);
         let __v_9: G = (__v_5 * __v_8);
-        let __ret: [G; OUT_587] = [__v_9];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_9];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_587] = [__v_5];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_5];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_587] = [__v_5];
-        record.function_queries[587].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_592] = [__v_5];
+        record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -50576,48 +50764,48 @@ fn aiur_fn_587(
   })
 }
 
-const INPUT_SIZE_588: usize = 2;
-const IN_588: usize = 2;
-const OUT_588: usize = 0;
-fn aiur_fn_588(
-  inp: [G; IN_588],
+const INPUT_SIZE_593: usize = 2;
+const IN_593: usize = 2;
+const OUT_593: usize = 0;
+fn aiur_fn_593(
+  inp: [G; IN_593],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_588], ExecError> {
+) -> Result<[G; OUT_593], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_588] = [];
-        record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_593] = [];
+        record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[587].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[587].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[587].bump_multiplicity(__i); } let __ret: [G; OUT_587] = unsafe { *(record.function_queries[587].output_at(__i).as_ptr() as *const [G; OUT_587]) }; __ret }, _ => aiur_fn_587(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = G::from_u64(1);
         if (__v_2 != __v_3) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("safe constant references an unsafe constant".to_string()) });
         }
-        let __ret: [G; OUT_588] = [];
-        record.function_queries[588].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_593] = [];
+        record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_589: usize = 2;
-const IN_589: usize = 2;
-const OUT_589: usize = 0;
-fn aiur_fn_589(
-  inp: [G; IN_589],
+const INPUT_SIZE_594: usize = 2;
+const IN_594: usize = 2;
+const OUT_594: usize = 0;
+fn aiur_fn_594(
+  inp: [G; IN_594],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_589], ExecError> {
+) -> Result<[G; OUT_594], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50627,28 +50815,28 @@ fn aiur_fn_589(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_589] = [];
-        record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_594] = [];
+        record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_589] = [];
-        record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_594] = [];
+        record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_589] = [];
-        record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_594] = [];
+        record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_589] = [];
-        record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_594] = [];
+        record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
@@ -50657,8 +50845,8 @@ fn aiur_fn_589(
         if (__v_5 != __v_6) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("universe param index out of range".to_string()) });
         }
-        let __ret: [G; OUT_589] = [];
-        record.function_queries[589].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_594] = [];
+        record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -50668,15 +50856,15 @@ fn aiur_fn_589(
   })
 }
 
-const INPUT_SIZE_590: usize = 2;
-const IN_590: usize = 2;
-const OUT_590: usize = 0;
-fn aiur_fn_590(
-  inp: [G; IN_590],
+const INPUT_SIZE_595: usize = 2;
+const IN_595: usize = 2;
+const OUT_595: usize = 0;
+fn aiur_fn_595(
+  inp: [G; IN_595],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_590], ExecError> {
+) -> Result<[G; OUT_595], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50686,15 +50874,15 @@ fn aiur_fn_590(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_590] = [];
-        record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_595] = [];
+        record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_590] = [];
-        record.function_queries[590].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_595] = [];
+        record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -50704,15 +50892,15 @@ fn aiur_fn_590(
   })
 }
 
-const INPUT_SIZE_591: usize = 3;
-const IN_591: usize = 3;
-const OUT_591: usize = 0;
-fn aiur_fn_591(
-  inp: [G; IN_591],
+const INPUT_SIZE_596: usize = 3;
+const IN_596: usize = 3;
+const OUT_596: usize = 0;
+fn aiur_fn_596(
+  inp: [G; IN_596],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_591], ExecError> {
+) -> Result<[G; OUT_596], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50729,18 +50917,18 @@ fn aiur_fn_591(
         if (__v_7 != __v_8) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("loose bound variable: BVar index exceeds binder depth".to_string()) });
         }
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[589].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[589].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[589].bump_multiplicity(__i); } let __ret: [G; OUT_589] = unsafe { *(record.function_queries[589].output_at(__i).as_ptr() as *const [G; OUT_589]) }; __ret }, _ => aiur_fn_589(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -50755,62 +50943,62 @@ fn aiur_fn_591(
         let __v_17: G = __loaded[9];
         let __v_18: G = __loaded[10];
         let __v_19: G = __loaded[11];
-        let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__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; let __hit = record.function_queries[430].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[430].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[430].bump_multiplicity(__i); } let __ret: [G; OUT_430] = unsafe { *(record.function_queries[430].output_at(__i).as_ptr() as *const [G; OUT_430]) }; __ret }, _ => aiur_fn_430(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__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; let __hit = record.function_queries[435].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[435].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[435].bump_multiplicity(__i); } let __ret: [G; OUT_435] = unsafe { *(record.function_queries[435].output_at(__i).as_ptr() as *const [G; OUT_435]) }; __ret }, _ => aiur_fn_435(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
         if (__v_21 != __v_20) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("Const applied to wrong number of universe levels".to_string()) });
         }
-        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = [__v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_1 + __v_7);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_591] = [];
-        record.function_queries[591].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_596] = [];
+        record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -50820,113 +51008,113 @@ fn aiur_fn_591(
   })
 }
 
-const INPUT_SIZE_592: usize = 0;
-const IN_592: usize = 0;
-const OUT_592: usize = 1;
-fn aiur_fn_592(
-  inp: [G; IN_592],
+const INPUT_SIZE_597: usize = 0;
+const IN_597: usize = 0;
+const OUT_597: usize = 1;
+fn aiur_fn_597(
+  inp: [G; IN_597],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_592], ExecError> {
+) -> Result<[G; OUT_597], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(231);
-    let __v_1: G = G::from_u64(117);
-    let __v_2: G = G::from_u64(170);
+    let __v_0: G = G::from_u64(69);
+    let __v_1: G = G::from_u64(4);
+    let __v_2: G = G::from_u64(11);
     let __v_3: G = G::from_u64(49);
-    let __v_4: G = G::from_u64(117);
-    let __v_5: G = G::from_u64(154);
-    let __v_6: G = G::from_u64(157);
-    let __v_7: G = G::from_u64(74);
-    let __v_8: G = G::from_u64(205);
-    let __v_9: G = G::from_u64(188);
-    let __v_10: G = G::from_u64(43);
-    let __v_11: G = G::from_u64(133);
-    let __v_12: G = G::from_u64(25);
-    let __v_13: G = G::from_u64(255);
-    let __v_14: G = G::from_u64(115);
-    let __v_15: G = G::from_u64(245);
-    let __v_16: G = G::from_u64(117);
-    let __v_17: G = G::from_u64(82);
-    let __v_18: G = G::from_u64(187);
-    let __v_19: G = G::from_u64(12);
-    let __v_20: G = G::from_u64(186);
-    let __v_21: G = G::from_u64(77);
-    let __v_22: G = G::from_u64(175);
-    let __v_23: G = G::from_u64(22);
-    let __v_24: G = G::from_u64(89);
-    let __v_25: G = G::from_u64(187);
-    let __v_26: G = G::from_u64(160);
-    let __v_27: G = G::from_u64(15);
-    let __v_28: G = G::from_u64(106);
-    let __v_29: G = G::from_u64(147);
-    let __v_30: G = G::from_u64(27);
-    let __v_31: G = G::from_u64(75);
+    let __v_4: G = G::from_u64(38);
+    let __v_5: G = G::from_u64(133);
+    let __v_6: G = G::from_u64(81);
+    let __v_7: G = G::from_u64(105);
+    let __v_8: G = G::from_u64(218);
+    let __v_9: G = G::from_u64(217);
+    let __v_10: G = G::from_u64(25);
+    let __v_11: G = G::from_u64(169);
+    let __v_12: G = G::from_u64(112);
+    let __v_13: G = G::from_u64(169);
+    let __v_14: G = G::from_u64(199);
+    let __v_15: G = G::from_u64(44);
+    let __v_16: G = G::from_u64(238);
+    let __v_17: G = G::from_u64(88);
+    let __v_18: G = G::from_u64(117);
+    let __v_19: G = G::from_u64(101);
+    let __v_20: G = G::from_u64(138);
+    let __v_21: G = G::from_u64(237);
+    let __v_22: G = G::from_u64(179);
+    let __v_23: G = G::from_u64(189);
+    let __v_24: G = G::from_u64(31);
+    let __v_25: G = G::from_u64(137);
+    let __v_26: G = G::from_u64(252);
+    let __v_27: G = G::from_u64(223);
+    let __v_28: G = G::from_u64(140);
+    let __v_29: G = G::from_u64(136);
+    let __v_30: G = G::from_u64(237);
+    let __v_31: G = G::from_u64(250);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_592] = [__v_32];
-    record.function_queries[592].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_597] = [__v_32];
+    record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_593: usize = 0;
-const IN_593: usize = 0;
-const OUT_593: usize = 1;
-fn aiur_fn_593(
-  inp: [G; IN_593],
+const INPUT_SIZE_598: usize = 0;
+const IN_598: usize = 0;
+const OUT_598: usize = 1;
+fn aiur_fn_598(
+  inp: [G; IN_598],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_593], ExecError> {
+) -> Result<[G; OUT_598], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __v_0: G = G::from_u64(178);
-    let __v_1: G = G::from_u64(14);
-    let __v_2: G = G::from_u64(161);
-    let __v_3: G = G::from_u64(123);
-    let __v_4: G = G::from_u64(163);
-    let __v_5: G = G::from_u64(217);
-    let __v_6: G = G::from_u64(114);
-    let __v_7: G = G::from_u64(63);
-    let __v_8: G = G::from_u64(11);
-    let __v_9: G = G::from_u64(208);
-    let __v_10: G = G::from_u64(100);
-    let __v_11: G = G::from_u64(87);
-    let __v_12: G = G::from_u64(217);
-    let __v_13: G = G::from_u64(207);
-    let __v_14: G = G::from_u64(72);
-    let __v_15: G = G::from_u64(206);
-    let __v_16: G = G::from_u64(38);
-    let __v_17: G = G::from_u64(202);
-    let __v_18: G = G::from_u64(54);
-    let __v_19: G = G::from_u64(97);
-    let __v_20: G = G::from_u64(155);
-    let __v_21: G = G::from_u64(148);
-    let __v_22: G = G::from_u64(105);
-    let __v_23: G = G::from_u64(128);
-    let __v_24: G = G::from_u64(98);
-    let __v_25: G = G::from_u64(125);
-    let __v_26: G = G::from_u64(233);
-    let __v_27: G = G::from_u64(35);
-    let __v_28: G = G::from_u64(135);
-    let __v_29: G = G::from_u64(62);
-    let __v_30: G = G::from_u64(149);
-    let __v_31: G = G::from_u64(149);
+    let __v_0: G = G::from_u64(195);
+    let __v_1: G = G::from_u64(125);
+    let __v_2: G = G::from_u64(98);
+    let __v_3: G = G::from_u64(144);
+    let __v_4: G = G::from_u64(224);
+    let __v_5: G = G::from_u64(15);
+    let __v_6: G = G::from_u64(184);
+    let __v_7: G = G::from_u64(101);
+    let __v_8: G = G::from_u64(251);
+    let __v_9: G = G::from_u64(93);
+    let __v_10: G = G::from_u64(183);
+    let __v_11: G = G::from_u64(188);
+    let __v_12: G = G::from_u64(225);
+    let __v_13: G = G::from_u64(143);
+    let __v_14: G = G::from_u64(214);
+    let __v_15: G = G::from_u64(158);
+    let __v_16: G = G::from_u64(109);
+    let __v_17: G = G::from_u64(22);
+    let __v_18: G = G::from_u64(116);
+    let __v_19: G = G::from_u64(173);
+    let __v_20: G = G::from_u64(87);
+    let __v_21: G = G::from_u64(55);
+    let __v_22: G = G::from_u64(36);
+    let __v_23: G = G::from_u64(184);
+    let __v_24: G = G::from_u64(84);
+    let __v_25: G = G::from_u64(102);
+    let __v_26: G = G::from_u64(234);
+    let __v_27: G = G::from_u64(159);
+    let __v_28: G = G::from_u64(117);
+    let __v_29: G = G::from_u64(120);
+    let __v_30: G = G::from_u64(162);
+    let __v_31: G = G::from_u64(7);
     let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __ret: [G; OUT_593] = [__v_32];
-    record.function_queries[593].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_598] = [__v_32];
+    record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_594: usize = 3;
-const IN_594: usize = 3;
-const OUT_594: usize = 1;
-fn aiur_fn_594(
-  inp: [G; IN_594],
+const INPUT_SIZE_599: usize = 3;
+const IN_599: usize = 3;
+const OUT_599: usize = 1;
+fn aiur_fn_599(
+  inp: [G; IN_599],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_594], ExecError> {
+) -> Result<[G; OUT_599], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -50935,8 +51123,8 @@ fn aiur_fn_594(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_594] = [__v_4];
-        record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_599] = [__v_4];
+        record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -50949,16 +51137,16 @@ fn aiur_fn_594(
           5u64 => {
             let __v_8: G = G::from_u64(1);
             let __v_9: G = (__v_2 + __v_8);
-            let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __ret: [G; OUT_594] = [__v_10];
-            record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_599] = [__v_10];
+            record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_594] = [__v_8];
-            record.function_queries[594].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_599] = [__v_8];
+            record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -50967,19 +51155,19 @@ fn aiur_fn_594(
   })
 }
 
-const INPUT_SIZE_595: usize = 0;
-const IN_595: usize = 0;
-const OUT_595: usize = 0;
-fn aiur_fn_595(
-  inp: [G; IN_595],
+const INPUT_SIZE_600: usize = 0;
+const IN_600: usize = 0;
+const OUT_600: usize = 0;
+fn aiur_fn_600(
+  inp: [G; IN_600],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_595], ExecError> {
+) -> Result<[G; OUT_600], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
-    let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = []; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } };
     let __v_0: G = __r_arr[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -51008,8 +51196,8 @@ fn aiur_fn_595(
         if (__v_7 != __v_16) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Eq inductive: wrong constructor count".to_string()) });
         }
-        let __ret: [G; OUT_595] = [];
-        record.function_queries[595].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_600] = [];
+        record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51019,15 +51207,15 @@ fn aiur_fn_595(
   })
 }
 
-const INPUT_SIZE_596: usize = 4;
-const IN_596: usize = 4;
-const OUT_596: usize = 0;
-fn aiur_fn_596(
-  inp: [G; IN_596],
+const INPUT_SIZE_601: usize = 4;
+const IN_601: usize = 4;
+const OUT_601: usize = 0;
+fn aiur_fn_601(
+  inp: [G; IN_601],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_596], ExecError> {
+) -> Result<[G; OUT_601], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51035,7 +51223,7 @@ fn aiur_fn_596(
     let __v_3: G = inp[3];
     let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() {
   0u64 => {
-    let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = []; let __cu = unconstrained; let __hit = record.function_queries[592].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[592].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[592].bump_multiplicity(__i); } let __ret: [G; OUT_592] = unsafe { *(record.function_queries[592].output_at(__i).as_ptr() as *const [G; OUT_592]) }; __ret }, _ => aiur_fn_592(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = []; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -51048,7 +51236,7 @@ fn aiur_fn_596(
     break '__mc_0 [__v_7, __v_8];
   },
   1u64 => {
-    let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = []; let __cu = unconstrained; let __hit = record.function_queries[382].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[382].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[382].bump_multiplicity(__i); } let __ret: [G; OUT_382] = unsafe { *(record.function_queries[382].output_at(__i).as_ptr() as *const [G; OUT_382]) }; __ret }, _ => aiur_fn_382(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = []; let __cu = unconstrained; let __hit = record.function_queries[387].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[387].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[387].bump_multiplicity(__i); } let __ret: [G; OUT_387] = unsafe { *(record.function_queries[387].output_at(__i).as_ptr() as *const [G; OUT_387]) }; __ret }, _ => aiur_fn_387(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -51061,7 +51249,7 @@ fn aiur_fn_596(
     break '__mc_0 [__v_7, __v_8];
   },
   2u64 => {
-    let __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = []; let __cu = unconstrained; let __hit = record.function_queries[383].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[383].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[383].bump_multiplicity(__i); } let __ret: [G; OUT_383] = unsafe { *(record.function_queries[383].output_at(__i).as_ptr() as *const [G; OUT_383]) }; __ret }, _ => aiur_fn_383(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = []; let __cu = unconstrained; let __hit = record.function_queries[388].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[388].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[388].bump_multiplicity(__i); } let __ret: [G; OUT_388] = unsafe { *(record.function_queries[388].output_at(__i).as_ptr() as *const [G; OUT_388]) }; __ret }, _ => aiur_fn_388(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -51069,13 +51257,13 @@ fn aiur_fn_596(
     if (__v_5 != __v_6) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("Quot.lift declared at a non-canonical address".to_string()) });
     }
-    let __r_arr: [G; OUT_595] = { let __args: [G; IN_595] = []; let __cu = unconstrained; let __hit = record.function_queries[595].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[595].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[595].bump_multiplicity(__i); } let __ret: [G; OUT_595] = unsafe { *(record.function_queries[595].output_at(__i).as_ptr() as *const [G; OUT_595]) }; __ret }, _ => aiur_fn_595(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = []; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } };
     let __v_7: G = G::from_u64(2);
     let __v_8: G = G::from_u64(6);
     break '__mc_0 [__v_7, __v_8];
   },
   3u64 => {
-    let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = []; let __cu = unconstrained; let __hit = record.function_queries[384].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[384].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[384].bump_multiplicity(__i); } let __ret: [G; OUT_384] = unsafe { *(record.function_queries[384].output_at(__i).as_ptr() as *const [G; OUT_384]) }; __ret }, _ => aiur_fn_384(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = []; let __cu = unconstrained; let __hit = record.function_queries[389].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[389].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[389].bump_multiplicity(__i); } let __ret: [G; OUT_389] = unsafe { *(record.function_queries[389].output_at(__i).as_ptr() as *const [G; OUT_389]) }; __ret }, _ => aiur_fn_389(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
@@ -51098,34 +51286,34 @@ fn aiur_fn_596(
       return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Quot constant: wrong universe param count for its kind".to_string()) });
     }
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[594].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[594].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[594].bump_multiplicity(__i); } let __ret: [G; OUT_594] = unsafe { *(record.function_queries[594].output_at(__i).as_ptr() as *const [G; OUT_594]) }; __ret }, _ => aiur_fn_594(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
     let __v_8: G = G::from_u64(1);
     if (__v_7 != __v_8) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_8.as_canonical_u64(), msg: Some("Quot constant: type has too few foralls for its kind".to_string()) });
     }
-    let __ret: [G; OUT_596] = [];
-    record.function_queries[596].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_601] = [];
+    record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_597: usize = 2;
-const IN_597: usize = 2;
-const OUT_597: usize = 1;
-fn aiur_fn_597(
-  inp: [G; IN_597],
+const INPUT_SIZE_602: usize = 2;
+const IN_602: usize = 2;
+const OUT_602: usize = 1;
+fn aiur_fn_602(
+  inp: [G; IN_602],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_597], ExecError> {
+) -> Result<[G; OUT_602], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_597] = [__v_0];
-        record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_602] = [__v_0];
+        record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51138,10 +51326,10 @@ fn aiur_fn_597(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
-            let __ret: [G; OUT_597] = [__v_8];
-            record.function_queries[597].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_602] = [__v_8];
+            record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -51153,29 +51341,29 @@ fn aiur_fn_597(
   })
 }
 
-const INPUT_SIZE_598: usize = 3;
-const IN_598: usize = 3;
-const OUT_598: usize = 0;
-fn aiur_fn_598(
-  inp: [G; IN_598],
+const INPUT_SIZE_603: usize = 3;
+const IN_603: usize = 3;
+const OUT_603: usize = 0;
+fn aiur_fn_603(
+  inp: [G; IN_603],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_598], ExecError> {
+) -> Result<[G; OUT_603], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = G::from_u64(0);
         if (__v_3 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("more universe levels than the inductive declares".to_string()) });
         }
-        let __ret: [G; OUT_598] = [];
-        record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_603] = [];
+        record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51198,9 +51386,9 @@ fn aiur_fn_598(
                 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_598] = { let __args: [G; IN_598] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_598] = [];
-                record.function_queries[598].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_603] = [];
+                record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -51217,15 +51405,15 @@ fn aiur_fn_598(
   })
 }
 
-const INPUT_SIZE_599: usize = 4;
-const IN_599: usize = 4;
-const OUT_599: usize = 0;
-fn aiur_fn_599(
-  inp: [G; IN_599],
+const INPUT_SIZE_604: usize = 4;
+const IN_604: usize = 4;
+const OUT_604: usize = 0;
+fn aiur_fn_604(
+  inp: [G; IN_604],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_599], ExecError> {
+) -> Result<[G; OUT_604], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51234,8 +51422,8 @@ fn aiur_fn_599(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_599] = [];
-        record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_604] = [];
+        record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51261,9 +51449,9 @@ fn aiur_fn_599(
                 }
                 let __v_16: G = G::from_u64(1);
                 let __v_17: G = (__v_3 + __v_16);
-                let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_7, __v_1, __v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_599] = [];
-                record.function_queries[599].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_7, __v_1, __v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_604] = [];
+                record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -51280,20 +51468,20 @@ fn aiur_fn_599(
   })
 }
 
-const INPUT_SIZE_600: usize = 3;
-const IN_600: usize = 3;
-const OUT_600: usize = 0;
-fn aiur_fn_600(
-  inp: [G; IN_600],
+const INPUT_SIZE_605: usize = 3;
+const IN_605: usize = 3;
+const OUT_605: usize = 0;
+fn aiur_fn_605(
+  inp: [G; IN_605],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_600], ExecError> {
+) -> Result<[G; OUT_605], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -51319,8 +51507,8 @@ fn aiur_fn_600(
         if (__v_12 != __v_2) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("ctor return head is a different member of the block".to_string()) });
         }
-        let __ret: [G; OUT_600] = [];
-        record.function_queries[600].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_605] = [];
+        record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51330,15 +51518,15 @@ fn aiur_fn_600(
   })
 }
 
-const INPUT_SIZE_601: usize = 7;
-const IN_601: usize = 7;
-const OUT_601: usize = 0;
-fn aiur_fn_601(
-  inp: [G; IN_601],
+const INPUT_SIZE_606: usize = 7;
+const IN_606: usize = 7;
+const OUT_606: usize = 0;
+fn aiur_fn_606(
+  inp: [G; IN_606],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_601], ExecError> {
+) -> Result<[G; OUT_606], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51348,9 +51536,9 @@ fn aiur_fn_601(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = (__v_1 + __v_3);
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -51360,32 +51548,32 @@ fn aiur_fn_601(
     let __v_14: G = __loaded[3];
     match __v_11.as_canonical_u64() {
       2u64 => {
-        let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[600].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[600].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[600].bump_multiplicity(__i); } let __ret: [G; OUT_600] = unsafe { *(record.function_queries[600].output_at(__i).as_ptr() as *const [G; OUT_600]) }; __ret }, _ => aiur_fn_600(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_12, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_13, __v_4, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = (__v_1 + __v_2);
         if (__v_16 != __v_17) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_17.as_canonical_u64(), msg: Some("ctor return type: wrong number of spine arguments".to_string()) });
         }
         let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_10, __v_1, __v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[599].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[599].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[599].bump_multiplicity(__i); } let __ret: [G; OUT_599] = unsafe { *(record.function_queries[599].output_at(__i).as_ptr() as *const [G; OUT_599]) }; __ret }, _ => aiur_fn_599(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_10, __v_1, __v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(0);
         let __v_21: G = G::from_u64(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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_24: G = { let __values: [G; 3] = [__v_20, __v_5, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_19, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_19, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } };
         let __v_25: G = __r_arr[0];
         let __v_26: G = G::from_u64(0);
         if (__v_25 != __v_26) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("ctor return type: reflexive occurrence in an index argument".to_string()) });
         }
-        let __ret: [G; OUT_601] = [];
-        record.function_queries[601].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_606] = [];
+        record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51395,15 +51583,15 @@ fn aiur_fn_601(
   })
 }
 
-const INPUT_SIZE_602: usize = 4;
-const IN_602: usize = 4;
-const OUT_602: usize = 0;
-fn aiur_fn_602(
-  inp: [G; IN_602],
+const INPUT_SIZE_607: usize = 4;
+const IN_607: usize = 4;
+const OUT_607: usize = 0;
+fn aiur_fn_607(
+  inp: [G; IN_607],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_602], ExecError> {
+) -> Result<[G; OUT_607], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51411,8 +51599,8 @@ fn aiur_fn_602(
     let __v_3: G = inp[3];
     match __v_2.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_602] = [];
-        record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_607] = [];
+        record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51430,7 +51618,7 @@ fn aiur_fn_602(
             let __v_11: G = __loaded[3];
             match __v_8.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_5, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
                 let __v_13: G = G::from_u64(1);
                 if (__v_12 != __v_13) {
@@ -51440,9 +51628,9 @@ fn aiur_fn_602(
                 let __v_15: G = { let __values: [G; 3] = [__v_14, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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 = (__v_2 - __v_16);
-                let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_6, __v_10, __v_17, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_602] = [];
-                record.function_queries[602].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_6, __v_10, __v_17, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_607] = [];
+                record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -51459,15 +51647,15 @@ fn aiur_fn_602(
   })
 }
 
-const INPUT_SIZE_603: usize = 3;
-const IN_603: usize = 3;
-const OUT_603: usize = 0;
-fn aiur_fn_603(
-  inp: [G; IN_603],
+const INPUT_SIZE_608: usize = 3;
+const IN_608: usize = 3;
+const OUT_608: usize = 0;
+fn aiur_fn_608(
+  inp: [G; IN_608],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_603], ExecError> {
+) -> Result<[G; OUT_608], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51475,27 +51663,27 @@ fn aiur_fn_603(
     let __v_3: G = G::from_u64(1);
     let __v_4: G = G::from_u64(1);
     let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_603] = [];
-    record.function_queries[603].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_608] = [];
+    record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_604: usize = 3;
-const IN_604: usize = 3;
-const OUT_604: usize = 1;
-fn aiur_fn_604(
-  inp: [G; IN_604],
+const INPUT_SIZE_609: usize = 3;
+const IN_609: usize = 3;
+const OUT_609: usize = 1;
+fn aiur_fn_609(
+  inp: [G; IN_609],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_604], ExecError> {
+) -> Result<[G; OUT_609], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     match __v_1.as_canonical_u64() {
       0u64 => {
@@ -51506,8 +51694,8 @@ fn aiur_fn_604(
         let __v_7: G = __loaded[3];
         match __v_4.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_604] = [__v_5];
-            record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_609] = [__v_5];
+            record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -51527,10 +51715,10 @@ fn aiur_fn_604(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_6, __v_9, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_604] = [__v_12];
-            record.function_queries[604].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_609] = [__v_12];
+            record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -51542,15 +51730,15 @@ fn aiur_fn_604(
   })
 }
 
-const INPUT_SIZE_605: usize = 3;
-const IN_605: usize = 3;
-const OUT_605: usize = 0;
-fn aiur_fn_605(
-  inp: [G; IN_605],
+const INPUT_SIZE_610: usize = 3;
+const IN_610: usize = 3;
+const OUT_610: usize = 0;
+fn aiur_fn_610(
+  inp: [G; IN_610],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_605], ExecError> {
+) -> Result<[G; OUT_610], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51562,9 +51750,9 @@ fn aiur_fn_605(
     let __v_6: G = __loaded[3];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[323].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[323].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[323].bump_multiplicity(__i); } let __ret: [G; OUT_323] = unsafe { *(record.function_queries[323].output_at(__i).as_ptr() as *const [G; OUT_323]) }; __ret }, _ => aiur_fn_323(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[328].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[328].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[328].bump_multiplicity(__i); } let __ret: [G; OUT_328] = unsafe { *(record.function_queries[328].output_at(__i).as_ptr() as *const [G; OUT_328]) }; __ret }, _ => aiur_fn_328(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = G::from_u64(1);
         if (__v_8 != __v_9) {
@@ -51572,29 +51760,29 @@ fn aiur_fn_605(
         }
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_605] = [];
-        record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_5, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_610] = [];
+        record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_605] = [];
-        record.function_queries[605].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_610] = [];
+        record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_606: usize = 4;
-const IN_606: usize = 4;
-const OUT_606: usize = 0;
-fn aiur_fn_606(
-  inp: [G; IN_606],
+const INPUT_SIZE_611: usize = 4;
+const IN_611: usize = 4;
+const OUT_611: usize = 0;
+fn aiur_fn_611(
+  inp: [G; IN_611],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_606], ExecError> {
+) -> Result<[G; OUT_611], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51602,9 +51790,9 @@ fn aiur_fn_606(
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[605].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[605].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[605].bump_multiplicity(__i); } let __ret: [G; OUT_605] = unsafe { *(record.function_queries[605].output_at(__i).as_ptr() as *const [G; OUT_605]) }; __ret }, _ => aiur_fn_605(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_606] = [];
-        record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_611] = [];
+        record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51619,9 +51807,9 @@ fn aiur_fn_606(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_606] = [];
-            record.function_queries[606].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_6, __v_9, __v_2, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_611] = [];
+            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -51633,15 +51821,15 @@ fn aiur_fn_606(
   })
 }
 
-const INPUT_SIZE_607: usize = 3;
-const IN_607: usize = 3;
-const OUT_607: usize = 0;
-fn aiur_fn_607(
-  inp: [G; IN_607],
+const INPUT_SIZE_612: usize = 3;
+const IN_612: usize = 3;
+const OUT_612: usize = 0;
+fn aiur_fn_612(
+  inp: [G; IN_612],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_607], ExecError> {
+) -> Result<[G; OUT_612], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51652,52 +51840,52 @@ fn aiur_fn_607(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_607] = [];
-        record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_612] = [];
+        record.function_queries[612].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_607] = [];
-        record.function_queries[607].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_1, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_612] = [];
+        record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_608: usize = 2;
-const IN_608: usize = 2;
-const OUT_608: usize = 1;
-fn aiur_fn_608(
-  inp: [G; IN_608],
+const INPUT_SIZE_613: usize = 2;
+const IN_613: usize = 2;
+const OUT_613: usize = 1;
+fn aiur_fn_613(
+  inp: [G; IN_613],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_608], ExecError> {
+) -> Result<[G; OUT_613], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __ret: [G; OUT_608] = [__v_2];
-    record.function_queries[608].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_613] = [__v_2];
+    record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_609: usize = 2;
-const IN_609: usize = 2;
-const OUT_609: usize = 1;
-fn aiur_fn_609(
-  inp: [G; IN_609],
+const INPUT_SIZE_614: usize = 2;
+const IN_614: usize = 2;
+const OUT_614: usize = 1;
+fn aiur_fn_614(
+  inp: [G; IN_614],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_609], ExecError> {
+) -> Result<[G; OUT_614], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51708,8 +51896,8 @@ fn aiur_fn_609(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_609] = [__v_5];
-        record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_614] = [__v_5];
+        record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -51718,15 +51906,15 @@ fn aiur_fn_609(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_609] = [__v_6];
-            record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_614] = [__v_6];
+            record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i); } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_609] = [__v_6];
-            record.function_queries[609].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_614] = [__v_6];
+            record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -51738,19 +51926,19 @@ fn aiur_fn_609(
   })
 }
 
-const INPUT_SIZE_610: usize = 2;
-const IN_610: usize = 2;
-const OUT_610: usize = 1;
-fn aiur_fn_610(
-  inp: [G; IN_610],
+const INPUT_SIZE_615: usize = 2;
+const IN_615: usize = 2;
+const OUT_615: usize = 1;
+fn aiur_fn_615(
+  inp: [G; IN_615],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_610], ExecError> {
+) -> Result<[G; OUT_615], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -51767,31 +51955,31 @@ fn aiur_fn_610(
     let __v_14: G = __loaded[11];
     match __v_3.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i); } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_610] = [__v_15];
-        record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_615] = [__v_15];
+        record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_15: G = G::from_u64(0);
-        let __ret: [G; OUT_610] = [__v_15];
-        record.function_queries[610].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_615] = [__v_15];
+        record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_611: usize = 2;
-const IN_611: usize = 2;
-const OUT_611: usize = 1;
-fn aiur_fn_611(
-  inp: [G; IN_611],
+const INPUT_SIZE_616: usize = 2;
+const IN_616: usize = 2;
+const OUT_616: usize = 1;
+fn aiur_fn_616(
+  inp: [G; IN_616],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_611], ExecError> {
+) -> Result<[G; OUT_616], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51803,105 +51991,105 @@ fn aiur_fn_611(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_611] = [__v_6];
-        record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_616] = [__v_6];
+        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_611] = [__v_6];
-        record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_616] = [__v_6];
+        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => aiur_fn_615(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_611] = [__v_6];
-        record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_616] = [__v_6];
+        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       4u64 => {
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       6u64 => {
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_7: G = G::from_u64(1);
-            let __ret: [G; OUT_611] = [__v_7];
-            record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_616] = [__v_7];
+            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
             let __v_7: G = __r_arr[0];
             match __v_7.as_canonical_u64() {
               1u64 => {
                 let __v_8: G = G::from_u64(1);
-                let __ret: [G; OUT_611] = [__v_8];
-                record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_616] = [__v_8];
+                record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
                 let __v_8: G = __r_arr[0];
-                let __ret: [G; OUT_611] = [__v_8];
-                record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_616] = [__v_8];
+                record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -51910,15 +52098,15 @@ fn aiur_fn_611(
       },
       7u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_611] = [__v_6];
-        record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_616] = [__v_6];
+        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_611] = [__v_6];
-        record.function_queries[611].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_616] = [__v_6];
+        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -51928,15 +52116,15 @@ fn aiur_fn_611(
   })
 }
 
-const INPUT_SIZE_612: usize = 2;
-const IN_612: usize = 2;
-const OUT_612: usize = 1;
-fn aiur_fn_612(
-  inp: [G; IN_612],
+const INPUT_SIZE_617: usize = 2;
+const IN_617: usize = 2;
+const OUT_617: usize = 1;
+fn aiur_fn_617(
+  inp: [G; IN_617],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_612], ExecError> {
+) -> Result<[G; OUT_617], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -51947,25 +52135,25 @@ fn aiur_fn_612(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_612] = [__v_5];
-        record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_617] = [__v_5];
+        record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_3, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_612] = [__v_6];
-            record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_617] = [__v_6];
+            record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_612] = [__v_6];
-            record.function_queries[612].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_617] = [__v_6];
+            record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -51977,23 +52165,23 @@ fn aiur_fn_612(
   })
 }
 
-const INPUT_SIZE_613: usize = 3;
-const IN_613: usize = 3;
-const OUT_613: usize = 2;
-fn aiur_fn_613(
-  inp: [G; IN_613],
+const INPUT_SIZE_618: usize = 3;
+const IN_618: usize = 3;
+const OUT_618: usize = 2;
+fn aiur_fn_618(
+  inp: [G; IN_618],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_613], ExecError> {
+) -> Result<[G; OUT_618], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_613] = [__v_0, __v_2];
-        record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_618] = [__v_0, __v_2];
+        record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -52008,16 +52196,16 @@ fn aiur_fn_613(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_613] = { let __args: [G; IN_613] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             let __v_12: G = __r_arr[1];
-            let __ret: [G; OUT_613] = [__v_11, __v_12];
-            record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_618] = [__v_11, __v_12];
+            record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_613] = [__v_0, __v_2];
-            record.function_queries[613].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_618] = [__v_0, __v_2];
+            record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -52026,15 +52214,15 @@ fn aiur_fn_613(
   })
 }
 
-const INPUT_SIZE_614: usize = 4;
-const IN_614: usize = 4;
-const OUT_614: usize = 0;
-fn aiur_fn_614(
-  inp: [G; IN_614],
+const INPUT_SIZE_619: usize = 4;
+const IN_619: usize = 4;
+const OUT_619: usize = 0;
+fn aiur_fn_619(
+  inp: [G; IN_619],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_614], ExecError> {
+) -> Result<[G; OUT_619], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52043,8 +52231,8 @@ fn aiur_fn_614(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_614] = [];
-        record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_619] = [];
+        record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -52069,9 +52257,9 @@ fn aiur_fn_614(
                 }
                 let __v_15: G = G::from_u64(1);
                 let __v_16: G = (__v_3 + __v_15);
-                let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i); } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_614] = [];
-                record.function_queries[614].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_7, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_619] = [];
+                record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -52088,22 +52276,22 @@ fn aiur_fn_614(
   })
 }
 
-const INPUT_SIZE_615: usize = 5;
-const IN_615: usize = 5;
-const OUT_615: usize = 0;
-fn aiur_fn_615(
-  inp: [G; IN_615],
+const INPUT_SIZE_620: usize = 5;
+const IN_620: usize = 5;
+const OUT_620: usize = 0;
+fn aiur_fn_620(
+  inp: [G; IN_620],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_615], ExecError> {
+) -> Result<[G; OUT_620], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_6: G = __loaded[0];
@@ -52121,25 +52309,25 @@ fn aiur_fn_615(
     match __v_6.as_canonical_u64() {
       5u64 => {
         let __v_18: G = G::from_u64(0);
-        let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[598].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[598].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[598].bump_multiplicity(__i); } let __ret: [G; OUT_598] = unsafe { *(record.function_queries[598].output_at(__i).as_ptr() as *const [G; OUT_598]) }; __ret }, _ => aiur_fn_598(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_1, __v_7, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = (__v_9 + __v_10);
         if (__v_19 != __v_20) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursive occurrence is not fully applied".to_string()) });
         }
         let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_2, __v_9, __v_4, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[614].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[614].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[614].bump_multiplicity(__i); } let __ret: [G; OUT_614] = unsafe { *(record.function_queries[614].output_at(__i).as_ptr() as *const [G; OUT_614]) }; __ret }, _ => aiur_fn_614(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_9, __v_4, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_22, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
         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: Some("recursive occurrence: index argument mentions the block".to_string()) });
         }
-        let __ret: [G; OUT_615] = [];
-        record.function_queries[615].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_620] = [];
+        record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -52149,30 +52337,30 @@ fn aiur_fn_615(
   })
 }
 
-const INPUT_SIZE_616: usize = 4;
-const IN_616: usize = 4;
-const OUT_616: usize = 0;
-fn aiur_fn_616(
-  inp: [G; IN_616],
+const INPUT_SIZE_621: usize = 4;
+const IN_621: usize = 4;
+const OUT_621: usize = 0;
+fn aiur_fn_621(
+  inp: [G; IN_621],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_616], ExecError> {
+) -> Result<[G; OUT_621], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_616] = [];
-        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_621] = [];
+        record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_6: G = __loaded[0];
@@ -52181,7 +52369,7 @@ fn aiur_fn_616(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[611].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[611].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[611].bump_multiplicity(__i); } let __ret: [G; OUT_611] = unsafe { *(record.function_queries[611].output_at(__i).as_ptr() as *const [G; OUT_611]) }; __ret }, _ => aiur_fn_611(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(0);
             if (__v_10 != __v_11) {
@@ -52189,13 +52377,13 @@ fn aiur_fn_616(
             }
             let __v_12: G = G::from_u64(0);
             let __v_13: G = { let __values: [G; 3] = [__v_12, __v_7, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_8, __v_1, __v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_616] = [];
-            record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_8, __v_1, __v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_621] = [];
+            record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -52205,28 +52393,28 @@ fn aiur_fn_616(
             let __v_15: G = __loaded[3];
             match __v_12.as_canonical_u64() {
               2u64 => {
-                let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[610].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[610].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[610].bump_multiplicity(__i); } let __ret: [G; OUT_610] = unsafe { *(record.function_queries[610].output_at(__i).as_ptr() as *const [G; OUT_610]) }; __ret }, _ => aiur_fn_610(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_13, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => aiur_fn_615(__args, record, io_buffer, __cu)? } };
                 let __v_16: G = __r_arr[0];
                 match __v_16.as_canonical_u64() {
                   1u64 => {
                     match __v_3.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
                         let __v_17: G = __r_arr[0];
-                        let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[615].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[615].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[615].bump_multiplicity(__i); } let __ret: [G; OUT_615] = unsafe { *(record.function_queries[615].output_at(__i).as_ptr() as *const [G; OUT_615]) }; __ret }, _ => aiur_fn_615(__args, record, io_buffer, __cu)? } };
-                        let __ret: [G; OUT_616] = [];
-                        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_13, __v_14, __v_11, __v_1, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => aiur_fn_620(__args, record, io_buffer, __cu)? } };
+                        let __ret: [G; OUT_621] = [];
+                        record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
-                        let __ret: [G; OUT_616] = [];
-                        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_621] = [];
+                        record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
-                    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_18: G = __loaded[0];
@@ -52243,9 +52431,9 @@ fn aiur_fn_616(
                     let __v_29: G = __loaded[11];
                     match __v_18.as_canonical_u64() {
                       5u64 => {
-                        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
                         let __v_30: G = __r_arr[0];
-                        let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_30, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_30, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } };
                         let __v_31: G = __r_arr[0];
                         let __v_32: G = G::from_u64(0);
                         if (__v_31 != __v_32) {
@@ -52253,14 +52441,14 @@ fn aiur_fn_616(
                         }
                         let __v_33: G = G::from_u64(0);
                         let __v_34: G = { let __values: [G; 3] = [__v_33, __v_25, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_11, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
                         let __v_35: G = __r_arr[0];
-                        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
                         let __v_36: G = __r_arr[0];
                         let __v_37: G = G::from_u64(0);
-                        let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_25, __v_26, __v_23, __v_34, __v_37, __v_21, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } };
-                        let __ret: [G; OUT_616] = [];
-                        record.function_queries[616].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_25, __v_26, __v_23, __v_34, __v_37, __v_21, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } };
+                        let __ret: [G; OUT_621] = [];
+                        record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -52281,15 +52469,15 @@ fn aiur_fn_616(
   })
 }
 
-const INPUT_SIZE_617: usize = 7;
-const IN_617: usize = 7;
-const OUT_617: usize = 0;
-fn aiur_fn_617(
-  inp: [G; IN_617],
+const INPUT_SIZE_622: usize = 7;
+const IN_622: usize = 7;
+const OUT_622: usize = 0;
+fn aiur_fn_622(
+  inp: [G; IN_622],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_617], ExecError> {
+) -> Result<[G; OUT_622], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52301,12 +52489,12 @@ fn aiur_fn_617(
     let __v_7: G = (__v_2 - __v_4);
     match __v_7.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_617] = [];
-        record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_622] = [];
+        record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_9: G = __loaded[0];
@@ -52326,22 +52514,22 @@ fn aiur_fn_617(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_11, __v_5, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } };
             let __v_24: G = __r_arr[0];
             let __v_25: G = __r_arr[1];
             let __v_26: G = G::from_u64(0);
-            let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[371].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[371].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[371].bump_multiplicity(__i); } let __ret: [G; OUT_371] = unsafe { *(record.function_queries[371].output_at(__i).as_ptr() as *const [G; OUT_371]) }; __ret }, _ => aiur_fn_371(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_24, __v_6, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[376].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[376].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[376].bump_multiplicity(__i); } let __ret: [G; OUT_376] = unsafe { *(record.function_queries[376].output_at(__i).as_ptr() as *const [G; OUT_376]) }; __ret }, _ => aiur_fn_376(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
             let __v_28: G = G::from_u64(1);
             let __v_29: G = G::from_u64(1);
             let __v_30: G = { let __values: [G; 3] = [__v_28, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_618] = { let __args: [G; IN_618] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_27, __v_3, __v_30, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__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_617] = { let __args: [G; IN_617] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[617].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[617].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[617].bump_multiplicity(__i); } let __ret: [G; OUT_617] = unsafe { *(record.function_queries[617].output_at(__i).as_ptr() as *const [G; OUT_617]) }; __ret }, _ => aiur_fn_617(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_617] = [];
-            record.function_queries[617].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_0, __v_1, __v_2, __v_3, __v_33, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_622] = [];
+            record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -52353,15 +52541,15 @@ fn aiur_fn_617(
   })
 }
 
-const INPUT_SIZE_618: usize = 4;
-const IN_618: usize = 4;
-const OUT_618: usize = 0;
-fn aiur_fn_618(
-  inp: [G; IN_618],
+const INPUT_SIZE_623: usize = 4;
+const IN_623: usize = 4;
+const OUT_623: usize = 0;
+fn aiur_fn_623(
+  inp: [G; IN_623],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_618], ExecError> {
+) -> Result<[G; OUT_623], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52374,32 +52562,32 @@ fn aiur_fn_618(
     let __v_7: G = __loaded[3];
     match __v_4.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[616].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[616].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[616].bump_multiplicity(__i); } let __ret: [G; OUT_616] = unsafe { *(record.function_queries[616].output_at(__i).as_ptr() as *const [G; OUT_616]) }; __ret }, _ => aiur_fn_616(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_618] = [];
-        record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_6, __v_1, __v_9, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_623] = [];
+        record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_618] = [];
-        record.function_queries[618].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_623] = [];
+        record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_619: usize = 4;
-const IN_619: usize = 4;
-const OUT_619: usize = 0;
-fn aiur_fn_619(
-  inp: [G; IN_619],
+const INPUT_SIZE_624: usize = 4;
+const IN_624: usize = 4;
+const OUT_624: usize = 0;
+fn aiur_fn_624(
+  inp: [G; IN_624],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_619], ExecError> {
+) -> Result<[G; OUT_624], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52410,26 +52598,26 @@ fn aiur_fn_619(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[613].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[613].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[613].bump_multiplicity(__i); } let __ret: [G; OUT_613] = unsafe { *(record.function_queries[613].output_at(__i).as_ptr() as *const [G; OUT_613]) }; __ret }, _ => aiur_fn_613(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__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_618] = { let __args: [G; IN_618] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[618].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[618].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[618].bump_multiplicity(__i); } let __ret: [G; OUT_618] = unsafe { *(record.function_queries[618].output_at(__i).as_ptr() as *const [G; OUT_618]) }; __ret }, _ => aiur_fn_618(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_619] = [];
-    record.function_queries[619].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_9, __v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_624] = [];
+    record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_620: usize = 8;
-const IN_620: usize = 8;
-const OUT_620: usize = 0;
-fn aiur_fn_620(
-  inp: [G; IN_620],
+const INPUT_SIZE_625: usize = 8;
+const IN_625: usize = 8;
+const OUT_625: usize = 0;
+fn aiur_fn_625(
+  inp: [G; IN_625],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_620], ExecError> {
+) -> Result<[G; OUT_625], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52443,25 +52631,25 @@ fn aiur_fn_620(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_0, __v_8, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__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_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_620] = [];
-    record.function_queries[620].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_12, __v_7, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_625] = [];
+    record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_621: usize = 10;
-const IN_621: usize = 10;
-const OUT_621: usize = 0;
-fn aiur_fn_621(
-  inp: [G; IN_621],
+const INPUT_SIZE_626: usize = 10;
+const IN_626: usize = 10;
+const OUT_626: usize = 0;
+fn aiur_fn_626(
+  inp: [G; IN_626],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_621], ExecError> {
+) -> Result<[G; OUT_626], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52476,12 +52664,12 @@ fn aiur_fn_621(
     let __v_10: G = (__v_3 - __v_9);
     match __v_10.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_621] = [];
-        record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_626] = [];
+        record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5, __v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__args, record, io_buffer, __cu)? } };
         let __v_11: 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_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_12: G = __loaded[0];
@@ -52513,15 +52701,15 @@ fn aiur_fn_621(
             if (__v_18 != __v_1) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_1.as_canonical_u64(), msg: Some("ctor parameter count differs from the inductive's".to_string()) });
             }
-            let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_0, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => aiur_fn_608(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_14, __v_18, __v_2, __v_19, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_14, __v_18, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } };
             let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_8.as_canonical_u64() {
   0u64 => {
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_14, __v_18, __v_5, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_14, __v_18, __v_5, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -52531,9 +52719,9 @@ fn aiur_fn_621(
  };
             let __v_26: G = G::from_u64(1);
             let __v_27: G = (__v_9 + __v_26);
-            let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[621].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[621].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[621].bump_multiplicity(__i); } let __ret: [G; OUT_621] = unsafe { *(record.function_queries[621].output_at(__i).as_ptr() as *const [G; OUT_621]) }; __ret }, _ => aiur_fn_621(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_621] = [];
-            record.function_queries[621].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_626] = [];
+            record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -52545,15 +52733,15 @@ fn aiur_fn_621(
   })
 }
 
-const INPUT_SIZE_622: usize = 12;
-const IN_622: usize = 12;
-const OUT_622: usize = 0;
-fn aiur_fn_622(
-  inp: [G; IN_622],
+const INPUT_SIZE_627: usize = 12;
+const IN_627: usize = 12;
+const OUT_627: usize = 0;
+fn aiur_fn_627(
+  inp: [G; IN_627],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_622], ExecError> {
+) -> Result<[G; OUT_627], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52569,29 +52757,29 @@ fn aiur_fn_622(
     let __v_11: G = inp[11];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => aiur_fn_620(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_622] = [];
-        record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_627] = [];
+        record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_622] = [];
-        record.function_queries[622].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_627] = [];
+        record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_623: usize = 13;
-const IN_623: usize = 13;
-const OUT_623: usize = 0;
-fn aiur_fn_623(
-  inp: [G; IN_623],
+const INPUT_SIZE_628: usize = 13;
+const IN_628: usize = 13;
+const OUT_628: usize = 0;
+fn aiur_fn_628(
+  inp: [G; IN_628],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_623], ExecError> {
+) -> Result<[G; OUT_628], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52612,12 +52800,12 @@ fn aiur_fn_623(
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_623] = [];
-            record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_628] = [];
+            record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -52671,14 +52859,14 @@ fn aiur_fn_623(
                 match __v_14.as_canonical_u64() {
                   8u64 => {
                     let __v_62: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_623] = [];
-                    record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_15, __v_2, __v_3, __v_4, __v_8, __v_62, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_628] = [];
+                    record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __ret: [G; OUT_623] = [];
-                    record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_628] = [];
+                    record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -52688,23 +52876,23 @@ fn aiur_fn_623(
         }
       },
       _ => {
-        let __ret: [G; OUT_623] = [];
-        record.function_queries[623].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_628] = [];
+        record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_624: usize = 7;
-const IN_624: usize = 7;
-const OUT_624: usize = 0;
-fn aiur_fn_624(
-  inp: [G; IN_624],
+const INPUT_SIZE_629: usize = 7;
+const IN_629: usize = 7;
+const OUT_629: usize = 0;
+fn aiur_fn_629(
+  inp: [G; IN_629],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_624], ExecError> {
+) -> Result<[G; OUT_629], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52763,8 +52951,8 @@ fn aiur_fn_624(
     let __v_53: G = __loaded[46];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_624] = [];
-        record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_629] = [];
+        record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -52776,13 +52964,13 @@ fn aiur_fn_624(
               1u64 => {
                 let __v_56: G = G::from_u64(1);
                 let __v_57: G = (__v_5 + __v_56);
-                let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_624] = [];
-                record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_57, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_629] = [];
+                record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_6, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_57: G = __loaded[0];
@@ -52802,20 +52990,20 @@ fn aiur_fn_624(
                     if (__v_60 != __v_2) {
                       return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("mutual block peers disagree on parameter count".to_string()) });
                     }
-                    let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_59, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => aiur_fn_608(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_1, __v_69, __v_72]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_59, __v_74, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } };
                     let __v_78: G = __r_arr[0];
-                    let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_73, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_73, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__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) {
@@ -52823,17 +53011,17 @@ fn aiur_fn_624(
                     }
                     let __v_81: G = G::from_u64(1);
                     let __v_82: G = (__v_5 + __v_81);
-                    let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_624] = [];
-                    record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_82, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_629] = [];
+                    record.function_queries[629].finish(&inp[..], &__ret[..], !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_624] = { let __args: [G; IN_624] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_624] = [];
-                    record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_70, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_629] = [];
+                    record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -52843,9 +53031,9 @@ fn aiur_fn_624(
           _ => {
             let __v_54: G = G::from_u64(1);
             let __v_55: G = (__v_5 + __v_54);
-            let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_624] = [];
-            record.function_queries[624].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_53, __v_1, __v_2, __v_3, __v_4, __v_55, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_629] = [];
+            record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -52857,15 +53045,15 @@ fn aiur_fn_624(
   })
 }
 
-const INPUT_SIZE_625: usize = 16;
-const IN_625: usize = 16;
-const OUT_625: usize = 1;
-fn aiur_fn_625(
-  inp: [G; IN_625],
+const INPUT_SIZE_630: usize = 16;
+const IN_630: usize = 16;
+const OUT_630: usize = 1;
+fn aiur_fn_630(
+  inp: [G; IN_630],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_625], ExecError> {
+) -> Result<[G; OUT_630], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52883,37 +53071,37 @@ fn aiur_fn_625(
     let __v_13: G = inp[13];
     let __v_14: G = inp[14];
     let __v_15: G = inp[15];
-    let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[297].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[297].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[297].bump_multiplicity(__i); } let __ret: [G; OUT_297] = unsafe { *(record.function_queries[297].output_at(__i).as_ptr() as *const [G; OUT_297]) }; __ret }, _ => aiur_fn_297(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[302].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[302].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[302].bump_multiplicity(__i); } let __ret: [G; OUT_302] = unsafe { *(record.function_queries[302].output_at(__i).as_ptr() as *const [G; OUT_302]) }; __ret }, _ => aiur_fn_302(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     match __v_16.as_canonical_u64() {
       1u64 => {
         let __v_17: G = G::from_u64(1);
-        let __ret: [G; OUT_625] = [__v_17];
-        record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_630] = [__v_17];
+        record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         match __v_15.as_canonical_u64() {
           0u64 => {
             let __v_17: G = G::from_u64(0);
-            let __ret: [G; OUT_625] = [__v_17];
-            record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_630] = [__v_17];
+            record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             match __v_1.as_canonical_u64() {
               0u64 => {
                 let __v_17: G = G::from_u64(1);
-                let __ret: [G; OUT_625] = [__v_17];
-                record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_630] = [__v_17];
+                record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               1u64 => {
                 match __v_2.as_canonical_u64() {
                   0u64 => {
                     let __v_17: G = G::from_u64(0);
-                    let __ret: [G; OUT_625] = [__v_17];
-                    record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_630] = [__v_17];
+                    record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -52922,26 +53110,26 @@ fn aiur_fn_625(
                         match __v_10.as_canonical_u64() {
                           0u64 => {
                             let __v_17: G = G::from_u64(1);
-                            let __ret: [G; OUT_625] = [__v_17];
-                            record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_630] = [__v_17];
+                            record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
                             let __v_17: G = G::from_u64(1);
                             let __v_18: G = G::from_u64(1);
                             let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } };
+                            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_5, __v_9, __v_10, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } };
                             let __v_20: G = __r_arr[0];
-                            let __ret: [G; OUT_625] = [__v_20];
-                            record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_630] = [__v_20];
+                            record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
                       },
                       _ => {
                         let __v_17: G = G::from_u64(0);
-                        let __ret: [G; OUT_625] = [__v_17];
-                        record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_630] = [__v_17];
+                        record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -52950,8 +53138,8 @@ fn aiur_fn_625(
               },
               _ => {
                 let __v_17: G = G::from_u64(0);
-                let __ret: [G; OUT_625] = [__v_17];
-                record.function_queries[625].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_630] = [__v_17];
+                record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -52962,15 +53150,15 @@ fn aiur_fn_625(
   })
 }
 
-const INPUT_SIZE_626: usize = 4;
-const IN_626: usize = 4;
-const OUT_626: usize = 1;
-fn aiur_fn_626(
-  inp: [G; IN_626],
+const INPUT_SIZE_631: usize = 4;
+const IN_631: usize = 4;
+const OUT_631: usize = 1;
+fn aiur_fn_631(
+  inp: [G; IN_631],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_626], ExecError> {
+) -> Result<[G; OUT_631], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -52982,10 +53170,10 @@ fn aiur_fn_626(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0, __v_2, __v_4, __v_3, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_626] = [__v_8];
-        record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_631] = [__v_8];
+        record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -53000,16 +53188,16 @@ fn aiur_fn_626(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_626] = { let __args: [G; IN_626] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[626].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[626].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[626].bump_multiplicity(__i); } let __ret: [G; OUT_626] = unsafe { *(record.function_queries[626].output_at(__i).as_ptr() as *const [G; OUT_626]) }; __ret }, _ => aiur_fn_626(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_6, __v_11, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __ret: [G; OUT_626] = [__v_12];
-            record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_631] = [__v_12];
+            record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_626] = [__v_8];
-            record.function_queries[626].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_631] = [__v_8];
+            record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53018,15 +53206,15 @@ fn aiur_fn_626(
   })
 }
 
-const INPUT_SIZE_627: usize = 5;
-const IN_627: usize = 5;
-const OUT_627: usize = 1;
-fn aiur_fn_627(
-  inp: [G; IN_627],
+const INPUT_SIZE_632: usize = 5;
+const IN_632: usize = 5;
+const OUT_632: usize = 1;
+fn aiur_fn_632(
+  inp: [G; IN_632],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_627], ExecError> {
+) -> Result<[G; OUT_632], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53036,13 +53224,13 @@ fn aiur_fn_627(
     let __v_5: G = (__v_1 - __v_2);
     match __v_5.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
-        let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[628].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[628].bump_multiplicity(__i); } let __ret: [G; OUT_628] = unsafe { *(record.function_queries[628].output_at(__i).as_ptr() as *const [G; OUT_628]) }; __ret }, _ => aiur_fn_628(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_627] = [__v_8];
-        record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_632] = [__v_8];
+        record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -53053,13 +53241,13 @@ fn aiur_fn_627(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_7, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(0);
             let __v_13: G = G::from_u64(0);
             let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_10, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
             let __v_15: G = __r_arr[0];
             let __v_16: G = (__v_11 - __v_15);
             let __v_17: G = G::from_u64(1);
@@ -53081,16 +53269,16 @@ fn aiur_fn_627(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_627] = { let __args: [G; IN_627] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_8, __v_1, __v_24, __v_22, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
             let __v_25: G = __r_arr[0];
-            let __ret: [G; OUT_627] = [__v_25];
-            record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_632] = [__v_25];
+            record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_627] = [__v_10];
-            record.function_queries[627].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_632] = [__v_10];
+            record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53099,15 +53287,15 @@ fn aiur_fn_627(
   })
 }
 
-const INPUT_SIZE_628: usize = 2;
-const IN_628: usize = 2;
-const OUT_628: usize = 1;
-fn aiur_fn_628(
-  inp: [G; IN_628],
+const INPUT_SIZE_633: usize = 2;
+const IN_633: usize = 2;
+const OUT_633: usize = 1;
+fn aiur_fn_633(
+  inp: [G; IN_633],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_628], ExecError> {
+) -> Result<[G; OUT_633], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53118,25 +53306,25 @@ fn aiur_fn_628(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(1);
-        let __ret: [G; OUT_628] = [__v_5];
-        record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_633] = [__v_5];
+        record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_1, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(0);
-            let __ret: [G; OUT_628] = [__v_6];
-            record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_633] = [__v_6];
+            record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[628].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[628].bump_multiplicity(__i); } let __ret: [G; OUT_628] = unsafe { *(record.function_queries[628].output_at(__i).as_ptr() as *const [G; OUT_628]) }; __ret }, _ => aiur_fn_628(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_628] = [__v_6];
-            record.function_queries[628].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_633] = [__v_6];
+            record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53148,15 +53336,15 @@ fn aiur_fn_628(
   })
 }
 
-const INPUT_SIZE_629: usize = 2;
-const IN_629: usize = 2;
-const OUT_629: usize = 1;
-fn aiur_fn_629(
-  inp: [G; IN_629],
+const INPUT_SIZE_634: usize = 2;
+const IN_634: usize = 2;
+const OUT_634: usize = 1;
+fn aiur_fn_634(
+  inp: [G; IN_634],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_629], ExecError> {
+) -> Result<[G; OUT_634], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53167,8 +53355,8 @@ fn aiur_fn_629(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_629] = [__v_5];
-        record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_634] = [__v_5];
+        record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -53183,24 +53371,24 @@ fn aiur_fn_629(
             match __v_9.as_canonical_u64() {
               0u64 => {
                 let __v_10: G = G::from_u64(1);
-                let __ret: [G; OUT_629] = [__v_10];
-                record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_634] = [__v_10];
+                record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_629] = [__v_10];
-                record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_634] = [__v_10];
+                record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[629].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[629].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[629].bump_multiplicity(__i); } let __ret: [G; OUT_629] = unsafe { *(record.function_queries[629].output_at(__i).as_ptr() as *const [G; OUT_629]) }; __ret }, _ => aiur_fn_629(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_629] = [__v_9];
-            record.function_queries[629].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_634] = [__v_9];
+            record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53212,15 +53400,15 @@ fn aiur_fn_629(
   })
 }
 
-const INPUT_SIZE_630: usize = 13;
-const IN_630: usize = 13;
-const OUT_630: usize = 1;
-fn aiur_fn_630(
-  inp: [G; IN_630],
+const INPUT_SIZE_635: usize = 13;
+const IN_635: usize = 13;
+const OUT_635: usize = 1;
+fn aiur_fn_635(
+  inp: [G; IN_635],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_630], ExecError> {
+) -> Result<[G; OUT_635], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53237,13 +53425,13 @@ fn aiur_fn_630(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_7, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
         match __v_13.as_canonical_u64() {
           0u64 => {
             let __v_14: G = G::from_u64(0);
-            let __ret: [G; OUT_630] = [__v_14];
-            record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_635] = [__v_14];
+            record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -53251,25 +53439,25 @@ fn aiur_fn_630(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_2, __v_14, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_18, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__args, record, io_buffer, __cu)? } };
             let __v_22: G = __r_arr[0];
             match __v_22.as_canonical_u64() {
               0u64 => {
                 let __v_23: G = G::from_u64(0);
-                let __ret: [G; OUT_630] = [__v_23];
-                record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_635] = [__v_23];
+                record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 match __v_5.as_canonical_u64() {
                   1u64 => {
                     let __v_23: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_7, __v_8, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                     let __v_25: G = __loaded[0];
@@ -53287,22 +53475,22 @@ fn aiur_fn_630(
                     match __v_25.as_canonical_u64() {
                       6u64 => {
                         let __v_37: G = G::from_bool((__v_32 == G::ZERO));
-                        let __ret: [G; OUT_630] = [__v_37];
-                        record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_635] = [__v_37];
+                        record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_37: G = G::from_u64(0);
-                        let __ret: [G; OUT_630] = [__v_37];
-                        record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_635] = [__v_37];
+                        record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_23: G = G::from_u64(0);
-                    let __ret: [G; OUT_630] = [__v_23];
-                    record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_635] = [__v_23];
+                    record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -53313,23 +53501,23 @@ fn aiur_fn_630(
       },
       _ => {
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_630] = [__v_13];
-        record.function_queries[630].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_635] = [__v_13];
+        record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_631: usize = 2;
-const IN_631: usize = 2;
-const OUT_631: usize = 1;
-fn aiur_fn_631(
-  inp: [G; IN_631],
+const INPUT_SIZE_636: usize = 2;
+const IN_636: usize = 2;
+const OUT_636: usize = 1;
+fn aiur_fn_636(
+  inp: [G; IN_636],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_631], ExecError> {
+) -> Result<[G; OUT_636], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53338,12 +53526,12 @@ fn aiur_fn_631(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_631] = [__v_3];
-        record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_636] = [__v_3];
+        record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -53397,16 +53585,16 @@ fn aiur_fn_631(
             match __v_3.as_canonical_u64() {
               8u64 => {
                 let __v_51: G = G::from_u64(0);
-                let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_4, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
-                let __ret: [G; OUT_631] = [__v_52];
-                record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_636] = [__v_52];
+                record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_51: G = G::from_u64(0);
-                let __ret: [G; OUT_631] = [__v_51];
-                record.function_queries[631].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_636] = [__v_51];
+                record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -53417,18 +53605,18 @@ fn aiur_fn_631(
   })
 }
 
-const INPUT_SIZE_632: usize = 1;
-const IN_632: usize = 1;
-const OUT_632: usize = 1;
-fn aiur_fn_632(
-  inp: [G; IN_632],
+const INPUT_SIZE_637: usize = 1;
+const IN_637: usize = 1;
+const OUT_637: usize = 1;
+fn aiur_fn_637(
+  inp: [G; IN_637],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_632], ExecError> {
+) -> Result<[G; OUT_637], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -53482,14 +53670,14 @@ fn aiur_fn_632(
         match __v_1.as_canonical_u64() {
           8u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_632] = [__v_49];
-            record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_637] = [__v_49];
+            record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_632] = [__v_49];
-            record.function_queries[632].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_637] = [__v_49];
+            record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53498,15 +53686,15 @@ fn aiur_fn_632(
   })
 }
 
-const INPUT_SIZE_633: usize = 2;
-const IN_633: usize = 2;
-const OUT_633: usize = 1;
-fn aiur_fn_633(
-  inp: [G; IN_633],
+const INPUT_SIZE_638: usize = 2;
+const IN_638: usize = 2;
+const OUT_638: usize = 1;
+fn aiur_fn_638(
+  inp: [G; IN_638],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_633], ExecError> {
+) -> Result<[G; OUT_638], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53563,14 +53751,14 @@ fn aiur_fn_633(
         match __v_1.as_canonical_u64() {
           1u64 => {
             let __v_49: G = G::from_u64(1);
-            let __ret: [G; OUT_633] = [__v_49];
-            record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_638] = [__v_49];
+            record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_49: G = G::from_u64(0);
-            let __ret: [G; OUT_633] = [__v_49];
-            record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_638] = [__v_49];
+            record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53580,17 +53768,17 @@ fn aiur_fn_633(
           1u64 => {
             let __v_49: G = G::from_u64(1);
             let __v_50: G = (__v_1 + __v_49);
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_48, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
-            let __ret: [G; OUT_633] = [__v_51];
-            record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_638] = [__v_51];
+            record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[633].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[633].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[633].bump_multiplicity(__i); } let __ret: [G; OUT_633] = unsafe { *(record.function_queries[633].output_at(__i).as_ptr() as *const [G; OUT_633]) }; __ret }, _ => aiur_fn_633(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_48, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
-            let __ret: [G; OUT_633] = [__v_49];
-            record.function_queries[633].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_638] = [__v_49];
+            record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53602,15 +53790,15 @@ fn aiur_fn_633(
   })
 }
 
-const INPUT_SIZE_634: usize = 5;
-const IN_634: usize = 5;
-const OUT_634: usize = 1;
-fn aiur_fn_634(
-  inp: [G; IN_634],
+const INPUT_SIZE_639: usize = 5;
+const IN_639: usize = 5;
+const OUT_639: usize = 1;
+fn aiur_fn_639(
+  inp: [G; IN_639],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_634], ExecError> {
+) -> Result<[G; OUT_639], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53620,7 +53808,7 @@ fn aiur_fn_634(
     let __v_5: G = (__v_3 + __v_4);
     let __v_6: G = (__v_2 + __v_5);
     let __v_7: G = (__v_1 + __v_6);
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_9: G = __loaded[0];
@@ -53629,7 +53817,7 @@ fn aiur_fn_634(
     let __v_12: G = __loaded[3];
     match __v_9.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -53639,8 +53827,8 @@ fn aiur_fn_634(
         let __v_18: G = __loaded[3];
         match __v_15.as_canonical_u64() {
           2u64 => {
-            let __ret: [G; OUT_634] = [__v_16];
-            record.function_queries[634].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_639] = [__v_16];
+            record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -53655,15 +53843,15 @@ fn aiur_fn_634(
   })
 }
 
-const INPUT_SIZE_635: usize = 12;
-const IN_635: usize = 12;
-const OUT_635: usize = 1;
-fn aiur_fn_635(
-  inp: [G; IN_635],
+const INPUT_SIZE_640: usize = 12;
+const IN_640: usize = 12;
+const OUT_640: usize = 1;
+fn aiur_fn_640(
+  inp: [G; IN_640],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_635], ExecError> {
+) -> Result<[G; OUT_640], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53682,7 +53870,7 @@ fn aiur_fn_635(
         let __v_12: G = (__v_3 + __v_5);
         let __v_13: G = (__v_12 + __v_6);
         let __v_14: G = (__v_13 + __v_4);
-        let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_2, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
         let __v_16: G = __loaded[0];
@@ -53691,7 +53879,7 @@ fn aiur_fn_635(
         let __v_19: G = __loaded[3];
         match __v_16.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_17]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -53701,16 +53889,16 @@ fn aiur_fn_635(
             let __v_25: G = __loaded[3];
             match __v_22.as_canonical_u64() {
               2u64 => {
-                let __ret: [G; OUT_635] = [__v_24];
-                record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_640] = [__v_24];
+                record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_635] = [__v_28];
-                record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_640] = [__v_28];
+                record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -53719,8 +53907,8 @@ fn aiur_fn_635(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_635] = [__v_22];
-            record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_640] = [__v_22];
+            record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -53729,23 +53917,23 @@ fn aiur_fn_635(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_635] = [__v_14];
-        record.function_queries[635].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_640] = [__v_14];
+        record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_636: usize = 6;
-const IN_636: usize = 6;
-const OUT_636: usize = 1;
-fn aiur_fn_636(
-  inp: [G; IN_636],
+const INPUT_SIZE_641: usize = 6;
+const IN_641: usize = 6;
+const OUT_641: usize = 1;
+fn aiur_fn_641(
+  inp: [G; IN_641],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_636], ExecError> {
+) -> Result<[G; OUT_641], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53756,7 +53944,7 @@ fn aiur_fn_636(
     let __v_6: G = (__v_3 + __v_4);
     let __v_7: G = (__v_2 + __v_6);
     let __v_8: G = (__v_1 + __v_7);
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_10: G = __loaded[0];
@@ -53765,17 +53953,17 @@ fn aiur_fn_636(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_15, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_15, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         let __v_17: G = (__v_2 + __v_3);
         let __v_18: G = (__v_17 + __v_4);
-        let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_16, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_16, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __ret: [G; OUT_636] = [__v_19];
-        record.function_queries[636].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_641] = [__v_19];
+        record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -53785,15 +53973,15 @@ fn aiur_fn_636(
   })
 }
 
-const INPUT_SIZE_637: usize = 2;
-const IN_637: usize = 2;
-const OUT_637: usize = 1;
-fn aiur_fn_637(
-  inp: [G; IN_637],
+const INPUT_SIZE_642: usize = 2;
+const IN_642: usize = 2;
+const OUT_642: usize = 1;
+fn aiur_fn_642(
+  inp: [G; IN_642],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_637], ExecError> {
+) -> Result<[G; OUT_642], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53806,13 +53994,13 @@ fn aiur_fn_637(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_637] = [__v_7];
-        record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_642] = [__v_7];
+        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[346].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[346].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[346].bump_multiplicity(__i); } let __ret: [G; OUT_346] = unsafe { *(record.function_queries[346].output_at(__i).as_ptr() as *const [G; OUT_346]) }; __ret }, _ => aiur_fn_346(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_3, __v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[351].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[351].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[351].bump_multiplicity(__i); } let __ret: [G; OUT_351] = unsafe { *(record.function_queries[351].output_at(__i).as_ptr() as *const [G; OUT_351]) }; __ret }, _ => aiur_fn_351(__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) {
@@ -53820,13 +54008,13 @@ fn aiur_fn_637(
         }
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
-        let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[362].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[362].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[362].bump_multiplicity(__i); } let __ret: [G; OUT_362] = unsafe { *(record.function_queries[362].output_at(__i).as_ptr() as *const [G; OUT_362]) }; __ret }, _ => aiur_fn_362(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_3, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_637] = [__v_12];
-        record.function_queries[637].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_642] = [__v_12];
+        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -53836,15 +54024,15 @@ fn aiur_fn_637(
   })
 }
 
-const INPUT_SIZE_638: usize = 3;
-const IN_638: usize = 3;
-const OUT_638: usize = 1;
-fn aiur_fn_638(
-  inp: [G; IN_638],
+const INPUT_SIZE_643: usize = 3;
+const IN_643: usize = 3;
+const OUT_643: usize = 1;
+fn aiur_fn_643(
+  inp: [G; IN_643],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_638], ExecError> {
+) -> Result<[G; OUT_643], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -53855,8 +54043,8 @@ fn aiur_fn_638(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_638] = [__v_6];
-        record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_643] = [__v_6];
+        record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -53867,30 +54055,30 @@ fn aiur_fn_638(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_638] = [__v_12];
-        record.function_queries[638].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_643] = [__v_12];
+        record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_639: usize = 2;
-const IN_639: usize = 2;
-const OUT_639: usize = 1;
-fn aiur_fn_639(
-  inp: [G; IN_639],
+const INPUT_SIZE_644: usize = 2;
+const IN_644: usize = 2;
+const OUT_644: usize = 1;
+fn aiur_fn_644(
+  inp: [G; IN_644],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_639], ExecError> {
+) -> Result<[G; OUT_644], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -53944,14 +54132,14 @@ fn aiur_fn_639(
         match __v_2.as_canonical_u64() {
           8u64 => {
             let __v_50: G = G::from_u64(0);
-            let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_3, __v_3, __v_0, __v_1, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
-            let __ret: [G; OUT_639] = [__v_51];
-            record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_644] = [__v_51];
+            record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_51: G = __loaded[0];
@@ -53969,7 +54157,7 @@ fn aiur_fn_639(
             match __v_51.as_canonical_u64() {
               5u64 => {
                 let __v_63: G = G::from_u64(0);
-                let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_1, __v_52, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } };
                 let __v_64: G = __r_arr[0];
                 let __v_65: G = G::from_u64(0);
                 let __v_66: G = G::from_u64(0);
@@ -53980,16 +54168,16 @@ fn aiur_fn_639(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_639] = [__v_73];
-                record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_644] = [__v_73];
+                record.function_queries[644].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_639] = [__v_65];
-                record.function_queries[639].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_644] = [__v_65];
+                record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54000,15 +54188,15 @@ fn aiur_fn_639(
   })
 }
 
-const INPUT_SIZE_640: usize = 5;
-const IN_640: usize = 5;
-const OUT_640: usize = 1;
-fn aiur_fn_640(
-  inp: [G; IN_640],
+const INPUT_SIZE_645: usize = 5;
+const IN_645: usize = 5;
+const OUT_645: usize = 1;
+fn aiur_fn_645(
+  inp: [G; IN_645],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_640], ExecError> {
+) -> Result<[G; OUT_645], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54068,16 +54256,16 @@ fn aiur_fn_640(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_640] = [__v_54];
-        record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_645] = [__v_54];
+        record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_2, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_54: G = __loaded[0];
@@ -54104,7 +54292,7 @@ fn aiur_fn_640(
  };
             let __v_66: G = __mc_out___mc_0[0];
             let __v_67: G = G::from_u64(0);
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_3, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } };
             let __v_68: G = __r_arr[0];
             let __v_69: G = G::from_u64(0);
             let __v_70: G = G::from_u64(0);
@@ -54113,20 +54301,20 @@ fn aiur_fn_640(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_640] = { let __args: [G; IN_640] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_51, __v_2, __v_3, __v_75]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_640] = [__v_77];
-            record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_645] = [__v_77];
+            record.function_queries[645].finish(&inp[..], &__ret[..], !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_640] = { let __args: [G; IN_640] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_0, __v_51, __v_2, __v_3, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
-            let __ret: [G; OUT_640] = [__v_54];
-            record.function_queries[640].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_645] = [__v_54];
+            record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -54138,15 +54326,15 @@ fn aiur_fn_640(
   })
 }
 
-const INPUT_SIZE_641: usize = 3;
-const IN_641: usize = 3;
-const OUT_641: usize = 1;
-fn aiur_fn_641(
-  inp: [G; IN_641],
+const INPUT_SIZE_646: usize = 3;
+const IN_646: usize = 3;
+const OUT_646: usize = 1;
+fn aiur_fn_646(
+  inp: [G; IN_646],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_641], ExecError> {
+) -> Result<[G; OUT_646], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54161,8 +54349,8 @@ fn aiur_fn_641(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_9: G = G::from_u64(0);
-        let __ret: [G; OUT_641] = [__v_9];
-        record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_646] = [__v_9];
+        record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -54172,38 +54360,38 @@ fn aiur_fn_641(
             let __v_9: G = __r_arr[0];
             match __v_9.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_6, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
                 match __v_10.as_canonical_u64() {
                   1u64 => {
                     let __v_11: G = G::from_u64(1);
-                    let __ret: [G; OUT_641] = [__v_11];
-                    record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_646] = [__v_11];
+                    record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } };
                     let __v_11: G = __r_arr[0];
-                    let __ret: [G; OUT_641] = [__v_11];
-                    record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_646] = [__v_11];
+                    record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } };
                 let __v_10: G = __r_arr[0];
-                let __ret: [G; OUT_641] = [__v_10];
-                record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_646] = [__v_10];
+                record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           _ => {
-            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_641] = [__v_9];
-            record.function_queries[641].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_646] = [__v_9];
+            record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -54215,15 +54403,15 @@ fn aiur_fn_641(
   })
 }
 
-const INPUT_SIZE_642: usize = 2;
-const IN_642: usize = 2;
-const OUT_642: usize = 1;
-fn aiur_fn_642(
-  inp: [G; IN_642],
+const INPUT_SIZE_647: usize = 2;
+const IN_647: usize = 2;
+const OUT_647: usize = 1;
+fn aiur_fn_647(
+  inp: [G; IN_647],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_642], ExecError> {
+) -> Result<[G; OUT_647], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54231,8 +54419,8 @@ fn aiur_fn_642(
     match __v_2.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_642] = [__v_3];
-        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_647] = [__v_3];
+        record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -54254,22 +54442,22 @@ fn aiur_fn_642(
                 match __v_11.as_canonical_u64() {
                   0u64 => {
                     let __v_12: G = G::from_u64(1);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54282,16 +54470,16 @@ fn aiur_fn_642(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54308,24 +54496,24 @@ fn aiur_fn_642(
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[648].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i); } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => aiur_fn_648(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54338,28 +54526,28 @@ fn aiur_fn_642(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               3u64 => {
-                let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54372,28 +54560,28 @@ fn aiur_fn_642(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               4u64 => {
-                let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54406,28 +54594,28 @@ fn aiur_fn_642(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54440,40 +54628,40 @@ fn aiur_fn_642(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               6u64 => {
-                let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
                 match __v_11.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_5, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                     let __v_12: G = __r_arr[0];
                     match __v_12.as_canonical_u64() {
                       1u64 => {
-                        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                         let __v_13: G = __r_arr[0];
-                        let __ret: [G; OUT_642] = [__v_13];
-                        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_647] = [__v_13];
+                        record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_642] = [__v_13];
-                        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_647] = [__v_13];
+                        record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54486,16 +54674,16 @@ fn aiur_fn_642(
             let __v_10: G = __loaded[3];
             match __v_7.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[340].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[340].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[340].bump_multiplicity(__i); } let __ret: [G; OUT_340] = unsafe { *(record.function_queries[340].output_at(__i).as_ptr() as *const [G; OUT_340]) }; __ret }, _ => aiur_fn_340(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_4, __v_5, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[345].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[345].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[345].bump_multiplicity(__i); } let __ret: [G; OUT_345] = unsafe { *(record.function_queries[345].output_at(__i).as_ptr() as *const [G; OUT_345]) }; __ret }, _ => aiur_fn_345(__args, record, io_buffer, __cu)? } };
                 let __v_11: G = __r_arr[0];
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54515,32 +54703,32 @@ fn aiur_fn_642(
                     let __v_12: G = (__v_5 - __v_9);
                     match __v_12.as_canonical_u64() {
                       0u64 => {
-                        let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+                        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
                         let __v_13: G = __r_arr[0];
-                        let __ret: [G; OUT_642] = [__v_13];
-                        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_647] = [__v_13];
+                        record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
                         let __v_13: G = G::from_u64(0);
-                        let __ret: [G; OUT_642] = [__v_13];
-                        record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_647] = [__v_13];
+                        record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
                   },
                   _ => {
                     let __v_12: G = G::from_u64(0);
-                    let __ret: [G; OUT_642] = [__v_12];
-                    record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_647] = [__v_12];
+                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
                 let __v_11: G = G::from_u64(0);
-                let __ret: [G; OUT_642] = [__v_11];
-                record.function_queries[642].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_647] = [__v_11];
+                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54554,15 +54742,15 @@ fn aiur_fn_642(
   })
 }
 
-const INPUT_SIZE_643: usize = 2;
-const IN_643: usize = 2;
-const OUT_643: usize = 1;
-fn aiur_fn_643(
-  inp: [G; IN_643],
+const INPUT_SIZE_648: usize = 2;
+const IN_648: usize = 2;
+const OUT_648: usize = 1;
+fn aiur_fn_648(
+  inp: [G; IN_648],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_643], ExecError> {
+) -> Result<[G; OUT_648], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54579,14 +54767,14 @@ fn aiur_fn_643(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_643] = [__v_8];
-            record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_643] = [__v_8];
-            record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -54599,25 +54787,25 @@ fn aiur_fn_643(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_643] = [__v_8];
-            record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_648] = [__v_8];
+            record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[327].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[327].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[327].bump_multiplicity(__i); } let __ret: [G; OUT_327] = unsafe { *(record.function_queries[327].output_at(__i).as_ptr() as *const [G; OUT_327]) }; __ret }, _ => aiur_fn_327(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[332].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[332].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[332].bump_multiplicity(__i); } let __ret: [G; OUT_332] = unsafe { *(record.function_queries[332].output_at(__i).as_ptr() as *const [G; OUT_332]) }; __ret }, _ => aiur_fn_332(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[648].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i); } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => aiur_fn_648(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_643] = [__v_9];
-                record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_648] = [__v_9];
+                record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_643] = [__v_9];
-                record.function_queries[643].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_648] = [__v_9];
+                record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54634,15 +54822,15 @@ fn aiur_fn_643(
   })
 }
 
-const INPUT_SIZE_644: usize = 2;
-const IN_644: usize = 2;
-const OUT_644: usize = 1;
-fn aiur_fn_644(
-  inp: [G; IN_644],
+const INPUT_SIZE_649: usize = 2;
+const IN_649: usize = 2;
+const OUT_649: usize = 1;
+fn aiur_fn_649(
+  inp: [G; IN_649],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_644], ExecError> {
+) -> Result<[G; OUT_649], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54659,14 +54847,14 @@ fn aiur_fn_644(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(1);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_649] = [__v_8];
+            record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_649] = [__v_8];
+            record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -54679,25 +54867,25 @@ fn aiur_fn_644(
         match __v_5.as_canonical_u64() {
           1u64 => {
             let __v_8: G = G::from_u64(0);
-            let __ret: [G; OUT_644] = [__v_8];
-            record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_649] = [__v_8];
+            record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
             let __v_8: G = __r_arr[0];
             match __v_8.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } };
                 let __v_9: G = __r_arr[0];
-                let __ret: [G; OUT_644] = [__v_9];
-                record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_649] = [__v_9];
+                record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_9: G = G::from_u64(0);
-                let __ret: [G; OUT_644] = [__v_9];
-                record.function_queries[644].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_649] = [__v_9];
+                record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54714,15 +54902,15 @@ fn aiur_fn_644(
   })
 }
 
-const INPUT_SIZE_645: usize = 13;
-const IN_645: usize = 13;
-const OUT_645: usize = 1;
-fn aiur_fn_645(
-  inp: [G; IN_645],
+const INPUT_SIZE_650: usize = 13;
+const IN_650: usize = 13;
+const OUT_650: usize = 1;
+fn aiur_fn_650(
+  inp: [G; IN_650],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_645], ExecError> {
+) -> Result<[G; OUT_650], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54739,37 +54927,37 @@ fn aiur_fn_645(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_645] = [__v_13];
-        record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_650] = [__v_13];
+        record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_13: G = G::from_u64(1);
         let __v_14: G = G::from_u64(1);
         let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_645] = [__v_15];
-        record.function_queries[645].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_650] = [__v_15];
+        record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_646: usize = 2;
-const IN_646: usize = 2;
-const OUT_646: usize = 1;
-fn aiur_fn_646(
-  inp: [G; IN_646],
+const INPUT_SIZE_651: usize = 2;
+const IN_651: usize = 2;
+const OUT_651: usize = 1;
+fn aiur_fn_651(
+  inp: [G; IN_651],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_646], ExecError> {
+) -> Result<[G; OUT_651], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -54823,15 +55011,15 @@ fn aiur_fn_646(
         match __v_2.as_canonical_u64() {
           8u64 => {
             let __v_50: G = G::from_u64(0);
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_3, __v_3, __v_0, __v_50, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
-            let __ret: [G; OUT_646] = [__v_51];
-            record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_651] = [__v_51];
+            record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_646] = [__v_1];
-            record.function_queries[646].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_651] = [__v_1];
+            record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -54840,15 +55028,15 @@ fn aiur_fn_646(
   })
 }
 
-const INPUT_SIZE_647: usize = 5;
-const IN_647: usize = 5;
-const OUT_647: usize = 1;
-fn aiur_fn_647(
-  inp: [G; IN_647],
+const INPUT_SIZE_652: usize = 5;
+const IN_652: usize = 5;
+const OUT_652: usize = 1;
+fn aiur_fn_652(
+  inp: [G; IN_652],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_647], ExecError> {
+) -> Result<[G; OUT_652], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -54905,16 +55093,16 @@ fn aiur_fn_647(
     let __v_51: G = __loaded[46];
     match __v_5.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_647] = [__v_4];
-        record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_652] = [__v_4];
+        record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_6.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_52]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_52]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_54: G = __loaded[0];
@@ -54931,9 +55119,9 @@ fn aiur_fn_647(
             let __v_65: G = __loaded[11];
             match __v_54.as_canonical_u64() {
               7u64 => {
-                let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_56, __v_57, __v_59, __v_60, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
                 let __v_66: G = __r_arr[0];
-                let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_66]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_66]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
                 let __v_68: G = __loaded[0];
@@ -54950,20 +55138,20 @@ fn aiur_fn_647(
                 let __v_79: G = __loaded[11];
                 match __v_68.as_canonical_u64() {
                   5u64 => {
-                    let __ret: [G; OUT_647] = [__v_75];
-                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_652] = [__v_75];
+                    record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
-                    let __ret: [G; OUT_647] = [__v_4];
-                    record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_652] = [__v_4];
+                    record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
               },
               _ => {
-                let __ret: [G; OUT_647] = [__v_4];
-                record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_652] = [__v_4];
+                record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -54971,10 +55159,10 @@ fn aiur_fn_647(
           _ => {
             let __v_52: G = G::from_u64(1);
             let __v_53: G = (__v_3 + __v_52);
-            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_0, __v_51, __v_2, __v_53, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
-            let __ret: [G; OUT_647] = [__v_54];
-            record.function_queries[647].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_652] = [__v_54];
+            record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -54986,20 +55174,20 @@ fn aiur_fn_647(
   })
 }
 
-const INPUT_SIZE_648: usize = 3;
-const IN_648: usize = 3;
-const OUT_648: usize = 1;
-fn aiur_fn_648(
-  inp: [G; IN_648],
+const INPUT_SIZE_653: usize = 3;
+const IN_653: usize = 3;
+const OUT_653: usize = 1;
+fn aiur_fn_653(
+  inp: [G; IN_653],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_648], ExecError> {
+) -> Result<[G; OUT_653], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -55053,7 +55241,7 @@ fn aiur_fn_648(
     match __v_3.as_canonical_u64() {
       8u64 => {
         let __v_51: G = G::from_u64(0);
-        let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_4, __v_4, __v_0, __v_51, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } };
         let __v_52: G = __r_arr[0];
         break '__mc_0 [__v_52];
       },
@@ -55065,7 +55253,7 @@ fn aiur_fn_648(
 }
  };
     let __v_51: G = __mc_out___mc_0[0];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -55119,12 +55307,12 @@ fn aiur_fn_648(
     match __v_52.as_canonical_u64() {
       8u64 => {
         let __v_100: G = G::from_u64(0);
-        let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_53, __v_53, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } };
         let __v_101: G = __r_arr[0];
         break '__mc_1 [__v_101];
       },
       _ => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_51]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_101: G = __loaded[0];
@@ -55142,7 +55330,7 @@ fn aiur_fn_648(
         match __v_101.as_canonical_u64() {
           5u64 => {
             let __v_113: G = G::from_u64(0);
-            let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_2, __v_102, __v_113]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } };
             let __v_114: G = __r_arr[0];
             let __v_115: G = G::from_u64(0);
             let __v_116: G = G::from_u64(0);
@@ -55168,40 +55356,40 @@ fn aiur_fn_648(
 }
  };
     let __v_100: G = __mc_out___mc_1[0];
-    let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
     let __v_101: G = __r_arr[0];
     match __v_101.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_648] = [__v_100];
-        record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_653] = [__v_100];
+        record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_0, __v_51, __v_2, __v_100]; let __cu = unconstrained; let __hit = record.function_queries[654].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[654].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[654].bump_multiplicity(__i); } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => aiur_fn_654(__args, record, io_buffer, __cu)? } };
         let __v_102: G = __r_arr[0];
-        let __ret: [G; OUT_648] = [__v_102];
-        record.function_queries[648].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_653] = [__v_102];
+        record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_649: usize = 4;
-const IN_649: usize = 4;
-const OUT_649: usize = 1;
-fn aiur_fn_649(
-  inp: [G; IN_649],
+const INPUT_SIZE_654: usize = 4;
+const IN_654: usize = 4;
+const OUT_654: usize = 1;
+fn aiur_fn_654(
+  inp: [G; IN_654],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_649], ExecError> {
+) -> Result<[G; OUT_654], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -55255,15 +55443,15 @@ fn aiur_fn_649(
         match __v_4.as_canonical_u64() {
           8u64 => {
             let __v_52: G = G::from_u64(0);
-            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_5, __v_5, __v_0, __v_1, __v_2, __v_3, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
-            let __ret: [G; OUT_649] = [__v_53];
-            record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_654] = [__v_53];
+            record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_649] = [__v_3];
-            record.function_queries[649].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_654] = [__v_3];
+            record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -55272,15 +55460,15 @@ fn aiur_fn_649(
   })
 }
 
-const INPUT_SIZE_650: usize = 7;
-const IN_650: usize = 7;
-const OUT_650: usize = 1;
-fn aiur_fn_650(
-  inp: [G; IN_650],
+const INPUT_SIZE_655: usize = 7;
+const IN_655: usize = 7;
+const OUT_655: usize = 1;
+fn aiur_fn_655(
+  inp: [G; IN_655],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_650], ExecError> {
+) -> Result<[G; OUT_655], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55339,16 +55527,16 @@ fn aiur_fn_650(
     let __v_53: G = __loaded[46];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_650] = [__v_5];
-        record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_655] = [__v_5];
+        record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_8.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_54]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_54]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_56: G = __loaded[0];
@@ -55365,9 +55553,9 @@ fn aiur_fn_650(
             let __v_67: G = __loaded[11];
             let __mc_out___mc_0: [G; 5] = '__mc_0: { match __v_56.as_canonical_u64() {
   7u64 => {
-    let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_58, __v_59, __v_61, __v_62, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
     let __v_68: G = __r_arr[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_68]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_68]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_70: G = __loaded[0];
@@ -55426,39 +55614,39 @@ fn aiur_fn_650(
               0u64 => {
                 let __v_73: G = G::from_u64(1);
                 let __v_74: G = (__v_6 + __v_73);
-                let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
                 let __v_75: G = __r_arr[0];
-                let __ret: [G; OUT_650] = [__v_75];
-                record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_655] = [__v_75];
+                record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__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; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__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; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
                 let __v_73: G = __r_arr[0];
-                let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__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; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[635].bump_multiplicity(__i); } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__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; let __hit = record.function_queries[640].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[640].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[640].bump_multiplicity(__i); } let __ret: [G; OUT_640] = unsafe { *(record.function_queries[640].output_at(__i).as_ptr() as *const [G; OUT_640]) }; __ret }, _ => aiur_fn_640(__args, record, io_buffer, __cu)? } };
                 let __v_74: G = __r_arr[0];
-                let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_5, __v_69, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[646].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[646].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[646].bump_multiplicity(__i); } let __ret: [G; OUT_646] = unsafe { *(record.function_queries[646].output_at(__i).as_ptr() as *const [G; OUT_646]) }; __ret }, _ => aiur_fn_646(__args, record, io_buffer, __cu)? } };
                 let __v_75: G = __r_arr[0];
                 match __v_75.as_canonical_u64() {
                   1u64 => {
                     let __v_76: G = G::from_u64(1);
                     let __v_77: G = (__v_6 + __v_76);
-                    let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_77]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
                     let __v_78: G = __r_arr[0];
-                    let __ret: [G; OUT_650] = [__v_78];
-                    record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_655] = [__v_78];
+                    record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
                     let __v_76: G = G::from_u64(1);
-                    let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[784].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i); } let __ret: [G; OUT_784] = unsafe { *(record.function_queries[784].output_at(__i).as_ptr() as *const [G; OUT_784]) }; __ret }, _ => aiur_fn_784(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_5, __v_69, __v_76, __v_73, __v_74]; let __cu = unconstrained; let __hit = record.function_queries[789].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[789].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { *(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789]) }; __ret }, _ => aiur_fn_789(__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_650] = { let __args: [G; IN_650] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_77, __v_79]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
                     let __v_80: G = __r_arr[0];
-                    let __ret: [G; OUT_650] = [__v_80];
-                    record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_655] = [__v_80];
+                    record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -55468,10 +55656,10 @@ fn aiur_fn_650(
           _ => {
             let __v_54: G = G::from_u64(1);
             let __v_55: G = (__v_6 + __v_54);
-            let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_0, __v_53, __v_2, __v_3, __v_4, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
             let __v_56: G = __r_arr[0];
-            let __ret: [G; OUT_650] = [__v_56];
-            record.function_queries[650].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_655] = [__v_56];
+            record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -55483,15 +55671,15 @@ fn aiur_fn_650(
   })
 }
 
-const INPUT_SIZE_651: usize = 3;
-const IN_651: usize = 3;
-const OUT_651: usize = 2;
-fn aiur_fn_651(
-  inp: [G; IN_651],
+const INPUT_SIZE_656: usize = 3;
+const IN_656: usize = 3;
+const OUT_656: usize = 2;
+fn aiur_fn_656(
+  inp: [G; IN_656],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_651], ExecError> {
+) -> Result<[G; OUT_656], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55507,8 +55695,8 @@ fn aiur_fn_651(
       1u64 => {
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __ret: [G; OUT_651] = [__v_9, __v_10];
-        record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_656] = [__v_9, __v_10];
+        record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -55517,18 +55705,18 @@ fn aiur_fn_651(
         match __v_9.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(1);
-            let __ret: [G; OUT_651] = [__v_10, __v_2];
-            record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_656] = [__v_10, __v_2];
+            record.function_queries[656].finish(&inp[..], &__ret[..], !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_651] = { let __args: [G; IN_651] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i); } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => aiur_fn_651(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = __r_arr[1];
-            let __ret: [G; OUT_651] = [__v_12, __v_13];
-            record.function_queries[651].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_656] = [__v_12, __v_13];
+            record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -55540,15 +55728,15 @@ fn aiur_fn_651(
   })
 }
 
-const INPUT_SIZE_652: usize = 5;
-const IN_652: usize = 5;
-const OUT_652: usize = 2;
-fn aiur_fn_652(
-  inp: [G; IN_652],
+const INPUT_SIZE_657: usize = 5;
+const IN_657: usize = 5;
+const OUT_657: usize = 2;
+fn aiur_fn_657(
+  inp: [G; IN_657],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_652], ExecError> {
+) -> Result<[G; OUT_657], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55566,8 +55754,8 @@ fn aiur_fn_652(
       1u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_652] = [__v_11, __v_12];
-        record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_657] = [__v_11, __v_12];
+        record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -55588,7 +55776,7 @@ fn aiur_fn_652(
         let __v_13: G = __mc_out___mc_0[0];
         let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_2.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     break '__mc_1 [__v_14];
   },
@@ -55604,18 +55792,18 @@ fn aiur_fn_652(
         match __v_16.as_canonical_u64() {
           1u64 => {
             let __v_17: G = G::from_u64(1);
-            let __ret: [G; OUT_652] = [__v_17, __v_4];
-            record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_657] = [__v_17, __v_4];
+            record.function_queries[657].finish(&inp[..], &__ret[..], !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_652] = { let __args: [G; IN_652] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_10, __v_1, __v_2, __v_3, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } };
             let __v_19: G = __r_arr[0];
             let __v_20: G = __r_arr[1];
-            let __ret: [G; OUT_652] = [__v_19, __v_20];
-            record.function_queries[652].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_657] = [__v_19, __v_20];
+            record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -55627,15 +55815,15 @@ fn aiur_fn_652(
   })
 }
 
-const INPUT_SIZE_653: usize = 2;
-const IN_653: usize = 2;
-const OUT_653: usize = 4;
-fn aiur_fn_653(
-  inp: [G; IN_653],
+const INPUT_SIZE_658: usize = 2;
+const IN_658: usize = 2;
+const OUT_658: usize = 4;
+fn aiur_fn_658(
+  inp: [G; IN_658],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_653], ExecError> {
+) -> Result<[G; OUT_658], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55688,27 +55876,27 @@ fn aiur_fn_653(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_653] = [__v_40, __v_41, __v_44, __v_47];
-        record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_658] = [__v_40, __v_41, __v_44, __v_47];
+        record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_1.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_653] = [__v_3, __v_4, __v_5, __v_6];
-            record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_658] = [__v_3, __v_4, __v_5, __v_6];
+            record.function_queries[658].finish(&inp[..], &__ret[..], !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_653] = { let __args: [G; IN_653] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_7, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__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_653] = [__v_10, __v_11, __v_12, __v_13];
-            record.function_queries[653].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_658] = [__v_10, __v_11, __v_12, __v_13];
+            record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -55720,15 +55908,15 @@ fn aiur_fn_653(
   })
 }
 
-const INPUT_SIZE_654: usize = 4;
-const IN_654: usize = 4;
-const OUT_654: usize = 1;
-fn aiur_fn_654(
-  inp: [G; IN_654],
+const INPUT_SIZE_659: usize = 4;
+const IN_659: usize = 4;
+const OUT_659: usize = 1;
+fn aiur_fn_659(
+  inp: [G; IN_659],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_654], ExecError> {
+) -> Result<[G; OUT_659], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55742,20 +55930,20 @@ fn aiur_fn_654(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_654] = [__v_9];
-        record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_659] = [__v_9];
+        record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_5.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_654] = [__v_6];
-            record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_659] = [__v_6];
+            record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -55765,8 +55953,8 @@ fn aiur_fn_654(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_654] = [__v_11];
-            record.function_queries[654].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_659] = [__v_11];
+            record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -55775,15 +55963,15 @@ fn aiur_fn_654(
   })
 }
 
-const INPUT_SIZE_655: usize = 6;
-const IN_655: usize = 6;
-const OUT_655: usize = 1;
-fn aiur_fn_655(
-  inp: [G; IN_655],
+const INPUT_SIZE_660: usize = 6;
+const IN_660: usize = 6;
+const OUT_660: usize = 1;
+fn aiur_fn_660(
+  inp: [G; IN_660],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_655], ExecError> {
+) -> Result<[G; OUT_660], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55793,8 +55981,8 @@ fn aiur_fn_655(
     let __v_5: G = inp[5];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_655] = [__v_0];
-        record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_660] = [__v_0];
+        record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -55805,19 +55993,19 @@ fn aiur_fn_655(
         let __v_9: G = __loaded[3];
         match __v_6.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[654].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[654].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[654].bump_multiplicity(__i); } let __ret: [G; OUT_654] = unsafe { *(record.function_queries[654].output_at(__i).as_ptr() as *const [G; OUT_654]) }; __ret }, _ => aiur_fn_654(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[659].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[659].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[659].bump_multiplicity(__i); } let __ret: [G; OUT_659] = unsafe { *(record.function_queries[659].output_at(__i).as_ptr() as *const [G; OUT_659]) }; __ret }, _ => aiur_fn_659(__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_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
             let __v_13: G = G::from_u64(1);
             let __v_14: G = (__v_1 - __v_13);
             let __v_15: G = G::from_u64(1);
             let __v_16: G = (__v_5 + __v_15);
-            let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
             let __v_17: G = __r_arr[0];
-            let __ret: [G; OUT_655] = [__v_17];
-            record.function_queries[655].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_660] = [__v_17];
+            record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -55829,15 +56017,15 @@ fn aiur_fn_655(
   })
 }
 
-const INPUT_SIZE_656: usize = 2;
-const IN_656: usize = 2;
-const OUT_656: usize = 1;
-fn aiur_fn_656(
-  inp: [G; IN_656],
+const INPUT_SIZE_661: usize = 2;
+const IN_661: usize = 2;
+const OUT_661: usize = 1;
+fn aiur_fn_661(
+  inp: [G; IN_661],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_656], ExecError> {
+) -> Result<[G; OUT_661], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55846,8 +56034,8 @@ fn aiur_fn_656(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_656] = [__v_4];
-        record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_661] = [__v_4];
+        record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -55861,18 +56049,18 @@ fn aiur_fn_656(
             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_656] = { let __args: [G; IN_656] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_4, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_656] = [__v_10];
-            record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_661] = [__v_10];
+            record.function_queries[661].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_10: G = __loaded[0];
@@ -55884,19 +56072,19 @@ fn aiur_fn_656(
                 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_656] = { let __args: [G; IN_656] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_656] = [__v_18];
-                record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_661] = [__v_18];
+                record.function_queries[661].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_656] = [__v_16];
-                record.function_queries[656].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_661] = [__v_16];
+                record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -55907,15 +56095,15 @@ fn aiur_fn_656(
   })
 }
 
-const INPUT_SIZE_657: usize = 4;
-const IN_657: usize = 4;
-const OUT_657: usize = 1;
-fn aiur_fn_657(
-  inp: [G; IN_657],
+const INPUT_SIZE_662: usize = 4;
+const IN_662: usize = 4;
+const OUT_662: usize = 1;
+fn aiur_fn_662(
+  inp: [G; IN_662],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_657], ExecError> {
+) -> Result<[G; OUT_662], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55924,8 +56112,8 @@ fn aiur_fn_657(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_657] = [__v_0];
-        record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_662] = [__v_0];
+        record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -55941,25 +56129,25 @@ fn aiur_fn_657(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_15: G = G::from_u64(1);
         let __v_16: G = (__v_3 + __v_15);
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } };
         let __v_17: G = __r_arr[0];
-        let __ret: [G; OUT_657] = [__v_17];
-        record.function_queries[657].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_662] = [__v_17];
+        record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_658: usize = 3;
-const IN_658: usize = 3;
-const OUT_658: usize = 1;
-fn aiur_fn_658(
-  inp: [G; IN_658],
+const INPUT_SIZE_663: usize = 3;
+const IN_663: usize = 3;
+const OUT_663: usize = 1;
+fn aiur_fn_663(
+  inp: [G; IN_663],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_658], ExecError> {
+) -> Result<[G; OUT_663], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -55970,21 +56158,21 @@ fn aiur_fn_658(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_658] = [__v_0];
-        record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_663] = [__v_0];
+        record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __ret: [G; OUT_658] = [__v_11];
-        record.function_queries[658].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_663] = [__v_11];
+        record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -55994,15 +56182,15 @@ fn aiur_fn_658(
   })
 }
 
-const INPUT_SIZE_659: usize = 5;
-const IN_659: usize = 5;
-const OUT_659: usize = 1;
-fn aiur_fn_659(
-  inp: [G; IN_659],
+const INPUT_SIZE_664: usize = 5;
+const IN_664: usize = 5;
+const OUT_664: usize = 1;
+fn aiur_fn_664(
+  inp: [G; IN_664],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_659], ExecError> {
+) -> Result<[G; OUT_664], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56012,32 +56200,32 @@ fn aiur_fn_659(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_659] = [__v_6];
-        record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_664] = [__v_6];
+        record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __ret: [G; OUT_659] = [__v_5];
-        record.function_queries[659].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_664] = [__v_5];
+        record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_660: usize = 3;
-const IN_660: usize = 3;
-const OUT_660: usize = 1;
-fn aiur_fn_660(
-  inp: [G; IN_660],
+const INPUT_SIZE_665: usize = 3;
+const IN_665: usize = 3;
+const OUT_665: usize = 1;
+fn aiur_fn_665(
+  inp: [G; IN_665],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_660], ExecError> {
+) -> Result<[G; OUT_665], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56045,8 +56233,8 @@ fn aiur_fn_660(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_660] = [__v_0];
-        record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_665] = [__v_0];
+        record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56061,25 +56249,25 @@ fn aiur_fn_660(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_13: G = G::from_u64(1);
         let __v_14: G = (__v_2 + __v_13);
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } };
         let __v_15: G = __r_arr[0];
-        let __ret: [G; OUT_660] = [__v_15];
-        record.function_queries[660].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_665] = [__v_15];
+        record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_661: usize = 2;
-const IN_661: usize = 2;
-const OUT_661: usize = 1;
-fn aiur_fn_661(
-  inp: [G; IN_661],
+const INPUT_SIZE_666: usize = 2;
+const IN_666: usize = 2;
+const OUT_666: usize = 1;
+fn aiur_fn_666(
+  inp: [G; IN_666],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_661], ExecError> {
+) -> Result<[G; OUT_666], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56089,18 +56277,18 @@ fn aiur_fn_661(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_661] = [__v_0];
-        record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_666] = [__v_0];
+        record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(5);
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_661] = [__v_8];
-        record.function_queries[661].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_666] = [__v_8];
+        record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56110,15 +56298,15 @@ fn aiur_fn_661(
   })
 }
 
-const INPUT_SIZE_662: usize = 2;
-const IN_662: usize = 2;
-const OUT_662: usize = 2;
-fn aiur_fn_662(
-  inp: [G; IN_662],
+const INPUT_SIZE_667: usize = 2;
+const IN_667: usize = 2;
+const OUT_667: usize = 2;
+fn aiur_fn_667(
+  inp: [G; IN_667],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_662], ExecError> {
+) -> Result<[G; OUT_667], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56127,8 +56315,8 @@ fn aiur_fn_662(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_662] = [__v_4, __v_0];
-        record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_667] = [__v_4, __v_0];
+        record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56141,20 +56329,20 @@ fn aiur_fn_662(
           5u64 => {
             let __v_6: G = G::from_u64(1);
             let __v_7: G = (__v_1 - __v_6);
-            let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_662] = [__v_11, __v_9];
-            record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_667] = [__v_11, __v_9];
+            record.function_queries[667].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_10: G = __loaded[0];
@@ -56165,21 +56353,21 @@ fn aiur_fn_662(
               5u64 => {
                 let __v_14: G = G::from_u64(1);
                 let __v_15: G = (__v_1 - __v_14);
-                let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_12, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_662] = [__v_19, __v_17];
-                record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_667] = [__v_19, __v_17];
+                record.function_queries[667].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_662] = [__v_16, __v_0];
-                record.function_queries[662].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_667] = [__v_16, __v_0];
+                record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -56190,15 +56378,15 @@ fn aiur_fn_662(
   })
 }
 
-const INPUT_SIZE_663: usize = 3;
-const IN_663: usize = 3;
-const OUT_663: usize = 1;
-fn aiur_fn_663(
-  inp: [G; IN_663],
+const INPUT_SIZE_668: usize = 3;
+const IN_668: usize = 3;
+const OUT_668: usize = 1;
+fn aiur_fn_668(
+  inp: [G; IN_668],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_663], ExecError> {
+) -> Result<[G; OUT_668], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56212,21 +56400,21 @@ fn aiur_fn_663(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_663] = [__v_8];
-        record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_668] = [__v_8];
+        record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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_663] = { let __args: [G; IN_663] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_663] = [__v_11];
-        record.function_queries[663].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_668] = [__v_11];
+        record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56236,15 +56424,15 @@ fn aiur_fn_663(
   })
 }
 
-const INPUT_SIZE_664: usize = 6;
-const IN_664: usize = 6;
-const OUT_664: usize = 1;
-fn aiur_fn_664(
-  inp: [G; IN_664],
+const INPUT_SIZE_669: usize = 6;
+const IN_669: usize = 6;
+const OUT_669: usize = 1;
+fn aiur_fn_669(
+  inp: [G; IN_669],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_664], ExecError> {
+) -> Result<[G; OUT_669], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56254,33 +56442,33 @@ fn aiur_fn_664(
     let __v_5: G = inp[5];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_664] = [__v_6];
-        record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_669] = [__v_6];
+        record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_664] = [__v_7];
-        record.function_queries[664].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_669] = [__v_7];
+        record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_665: usize = 3;
-const IN_665: usize = 3;
-const OUT_665: usize = 1;
-fn aiur_fn_665(
-  inp: [G; IN_665],
+const INPUT_SIZE_670: usize = 3;
+const IN_670: usize = 3;
+const OUT_670: usize = 1;
+fn aiur_fn_670(
+  inp: [G; IN_670],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_665], ExecError> {
+) -> Result<[G; OUT_670], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56288,8 +56476,8 @@ fn aiur_fn_665(
     let __v_3: G = (__v_1 - __v_2);
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_665] = [__v_0];
-        record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_670] = [__v_0];
+        record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56302,25 +56490,25 @@ fn aiur_fn_665(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_11: G = G::from_u64(1);
         let __v_12: G = (__v_2 + __v_11);
-        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_665] = [__v_13];
-        record.function_queries[665].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_670] = [__v_13];
+        record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_666: usize = 9;
-const IN_666: usize = 9;
-const OUT_666: usize = 1;
-fn aiur_fn_666(
-  inp: [G; IN_666],
+const INPUT_SIZE_671: usize = 9;
+const IN_671: usize = 9;
+const OUT_671: usize = 1;
+fn aiur_fn_671(
+  inp: [G; IN_671],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_666], ExecError> {
+) -> Result<[G; OUT_671], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56331,12 +56519,12 @@ fn aiur_fn_666(
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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_655] = { let __args: [G; IN_655] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_9, __v_2, __v_6, __v_7, __v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
     let __v_11: G = __r_arr[0];
-    let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_11, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     let __v_13: G = G::from_u64(2);
     let __v_14: G = G::from_u64(0);
@@ -56344,12 +56532,12 @@ fn aiur_fn_666(
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() {
   0u64 => {
     let __v_16: G = G::from_u64(0);
-    let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_15, __v_6, __v_3, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
     break '__mc_0 [__v_17];
   },
   _ => {
-    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_15, __v_8, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     break '__mc_0 [__v_16];
   },
@@ -56357,7 +56545,7 @@ fn aiur_fn_666(
  };
     let __v_16: G = __mc_out___mc_0[0];
     let __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_16, __v_3, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = G::from_u64(1);
     let __v_20: G = G::from_u64(0);
@@ -56365,45 +56553,45 @@ fn aiur_fn_666(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_24, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_24, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
     let __v_25: G = __r_arr[0];
-    let __ret: [G; OUT_666] = [__v_25];
-    record.function_queries[666].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_671] = [__v_25];
+    record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_667: usize = 3;
-const IN_667: usize = 3;
-const OUT_667: usize = 1;
-fn aiur_fn_667(
-  inp: [G; IN_667],
+const INPUT_SIZE_672: usize = 3;
+const IN_672: usize = 3;
+const OUT_672: usize = 1;
+fn aiur_fn_672(
+  inp: [G; IN_672],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_667], ExecError> {
+) -> Result<[G; OUT_672], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = G::from_u64(0);
-    let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_667] = [__v_4];
-    record.function_queries[667].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_672] = [__v_4];
+    record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_668: usize = 4;
-const IN_668: usize = 4;
-const OUT_668: usize = 1;
-fn aiur_fn_668(
-  inp: [G; IN_668],
+const INPUT_SIZE_673: usize = 4;
+const IN_673: usize = 4;
+const OUT_673: usize = 1;
+fn aiur_fn_673(
+  inp: [G; IN_673],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_668], ExecError> {
+) -> Result<[G; OUT_673], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56412,8 +56600,8 @@ fn aiur_fn_668(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_668] = [__v_0];
-        record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_673] = [__v_0];
+        record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56426,25 +56614,25 @@ fn aiur_fn_668(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_3 + __v_12);
-        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
-        let __ret: [G; OUT_668] = [__v_14];
-        record.function_queries[668].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_673] = [__v_14];
+        record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_669: usize = 2;
-const IN_669: usize = 2;
-const OUT_669: usize = 1;
-fn aiur_fn_669(
-  inp: [G; IN_669],
+const INPUT_SIZE_674: usize = 2;
+const IN_674: usize = 2;
+const OUT_674: usize = 1;
+fn aiur_fn_674(
+  inp: [G; IN_674],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_669], ExecError> {
+) -> Result<[G; OUT_674], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56454,18 +56642,18 @@ fn aiur_fn_669(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_669] = [__v_0];
-        record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_674] = [__v_0];
+        record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(4);
-        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[669].bump_multiplicity(__i); } let __ret: [G; OUT_669] = unsafe { *(record.function_queries[669].output_at(__i).as_ptr() as *const [G; OUT_669]) }; __ret }, _ => aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_669] = [__v_8];
-        record.function_queries[669].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_674] = [__v_8];
+        record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56475,15 +56663,15 @@ fn aiur_fn_669(
   })
 }
 
-const INPUT_SIZE_670: usize = 9;
-const IN_670: usize = 9;
-const OUT_670: usize = 1;
-fn aiur_fn_670(
-  inp: [G; IN_670],
+const INPUT_SIZE_675: usize = 9;
+const IN_675: usize = 9;
+const OUT_675: usize = 1;
+fn aiur_fn_675(
+  inp: [G; IN_675],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_670], ExecError> {
+) -> Result<[G; OUT_675], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56495,12 +56683,12 @@ fn aiur_fn_670(
     let __v_7: G = inp[7];
     let __v_8: G = inp[8];
     let __v_9: G = G::from_u64(0);
-    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_6, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
     let __v_11: G = __r_arr[1];
     let __v_12: G = __r_arr[2];
     let __v_13: G = __r_arr[3];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_15: G = __loaded[0];
@@ -56517,32 +56705,32 @@ fn aiur_fn_670(
     let __v_26: G = __loaded[11];
     match __v_15.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_17, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __ret: [G; OUT_670] = [__v_27];
-        record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_675] = [__v_27];
+        record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0, __v_1, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } };
         let __v_27: G = __r_arr[0];
-        let __ret: [G; OUT_670] = [__v_27];
-        record.function_queries[670].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_675] = [__v_27];
+        record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_671: usize = 11;
-const IN_671: usize = 11;
-const OUT_671: usize = 1;
-fn aiur_fn_671(
-  inp: [G; IN_671],
+const INPUT_SIZE_676: usize = 11;
+const IN_676: usize = 11;
+const OUT_676: usize = 1;
+fn aiur_fn_676(
+  inp: [G; IN_676],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_671], ExecError> {
+) -> Result<[G; OUT_676], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56555,28 +56743,28 @@ fn aiur_fn_671(
     let __v_8: G = inp[8];
     let __v_9: G = inp[9];
     let __v_10: G = inp[10];
-    let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[789].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[789].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { *(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789]) }; __ret }, _ => aiur_fn_789(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[794].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[794].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { *(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794]) }; __ret }, _ => aiur_fn_794(__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_638] = { let __args: [G; IN_638] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[638].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[638].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[638].bump_multiplicity(__i); } let __ret: [G; OUT_638] = unsafe { *(record.function_queries[638].output_at(__i).as_ptr() as *const [G; OUT_638]) }; __ret }, _ => aiur_fn_638(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_7, __v_1, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[643].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[643].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[643].bump_multiplicity(__i); } let __ret: [G; OUT_643] = unsafe { *(record.function_queries[643].output_at(__i).as_ptr() as *const [G; OUT_643]) }; __ret }, _ => aiur_fn_643(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
-    let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[662].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[662].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[662].bump_multiplicity(__i); } let __ret: [G; OUT_662] = unsafe { *(record.function_queries[662].output_at(__i).as_ptr() as *const [G; OUT_662]) }; __ret }, _ => aiur_fn_662(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_14, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
-    let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[667].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[667].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[667].bump_multiplicity(__i); } let __ret: [G; OUT_667] = unsafe { *(record.function_queries[667].output_at(__i).as_ptr() as *const [G; OUT_667]) }; __ret }, _ => aiur_fn_667(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_8, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[672].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[672].bump_multiplicity(__i); } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => aiur_fn_672(__args, record, io_buffer, __cu)? } };
     let __v_17: G = __r_arr[0];
-    let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[685].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[685].bump_multiplicity(__i); } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => aiur_fn_685(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_8, __v_9, __v_4, __v_11, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_19: G = __r_arr[0];
-    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_8, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__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 __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_25: G = __loaded[0];
@@ -56593,16 +56781,16 @@ fn aiur_fn_671(
     let __v_36: G = __loaded[11];
     match __v_25.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_27, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_27, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__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_655] = { let __args: [G; IN_655] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[655].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[655].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[655].bump_multiplicity(__i); } let __ret: [G; OUT_655] = unsafe { *(record.function_queries[655].output_at(__i).as_ptr() as *const [G; OUT_655]) }; __ret }, _ => aiur_fn_655(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_37, __v_28, __v_4, __v_21, __v_22, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
         let __v_39: G = __r_arr[0];
-        let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_39, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_39, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
         let __v_41: G = (__v_11 + __v_19);
         let __v_42: G = G::from_u64(0);
-        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_40, __v_41, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__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);
@@ -56616,13 +56804,13 @@ fn aiur_fn_671(
         let __v_53: G = (__v_52 + __v_5);
         let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_21.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_46, __v_22, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
     let __v_54: G = __r_arr[0];
     break '__mc_0 [__v_54];
   },
   _ => {
     let __v_54: G = G::from_u64(0);
-    let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_46, __v_4, __v_51, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } };
     let __v_55: G = __r_arr[0];
     break '__mc_0 [__v_55];
   },
@@ -56630,7 +56818,7 @@ fn aiur_fn_671(
  };
         let __v_54: G = __mc_out___mc_0[0];
         let __v_55: G = G::from_u64(0);
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_54, __v_5, __v_55]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } };
         let __v_56: G = __r_arr[0];
         let __v_57: G = G::from_u64(1);
         let __v_58: G = (__v_49 + __v_57);
@@ -56642,7 +56830,7 @@ fn aiur_fn_671(
         let __v_64: G = G::from_u64(0);
         let __v_65: G = { let __values: [G; 4] = [__v_63, __v_62, __v_64, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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 __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_65, __v_5, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } };
         let __v_67: G = __r_arr[0];
         let __v_68: G = G::from_u64(3);
         let __v_69: G = G::from_u64(0);
@@ -56654,16 +56842,16 @@ fn aiur_fn_671(
         let __v_75: G = G::from_u64(5);
         let __v_76: G = G::from_u64(0);
         let __v_77: G = { let __values: [G; 4] = [__v_75, __v_56, __v_74, __v_76]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_77, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_77, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
         let __v_78: G = __r_arr[0];
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_78, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_78, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
         let __v_79: G = __r_arr[0];
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_79, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_79, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
         let __v_80: G = __r_arr[0];
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_80, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_80, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
         let __v_81: G = __r_arr[0];
-        let __ret: [G; OUT_671] = [__v_81];
-        record.function_queries[671].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_676] = [__v_81];
+        record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56673,15 +56861,15 @@ fn aiur_fn_671(
   })
 }
 
-const INPUT_SIZE_672: usize = 26;
-const IN_672: usize = 26;
-const OUT_672: usize = 0;
-fn aiur_fn_672(
-  inp: [G; IN_672],
+const INPUT_SIZE_677: usize = 26;
+const IN_677: usize = 26;
+const OUT_677: usize = 0;
+fn aiur_fn_677(
+  inp: [G; IN_677],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_672], ExecError> {
+) -> Result<[G; OUT_677], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56716,7 +56904,7 @@ fn aiur_fn_672(
             let __mc_out___mc_0: [G; 13] = '__mc_0: { match __v_18.as_canonical_u64() {
   1u64 => {
     let __v_26: G = G::from_u64(0);
-    let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_20, __v_21, __v_26]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_28: G = __loaded[0];
@@ -56767,11 +56955,11 @@ fn aiur_fn_672(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_15, __v_39, __v_42]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } };
             let __v_43: G = __r_arr[0];
-            let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[631].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[631].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[631].bump_multiplicity(__i); } let __ret: [G; OUT_631] = unsafe { *(record.function_queries[631].output_at(__i).as_ptr() as *const [G; OUT_631]) }; __ret }, _ => aiur_fn_631(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_20, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } };
             let __v_44: G = __r_arr[0];
-            let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__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, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__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, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } };
             let __v_45: G = __r_arr[0];
             let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_45.as_canonical_u64() {
   1u64 => {
@@ -56791,17 +56979,17 @@ fn aiur_fn_672(
  };
             let __v_46: G = __mc_out___mc_1[0];
             let __v_47: G = G::from_u64(0);
-            let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_1, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_1, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
             let __v_48: G = __r_arr[0];
-            let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[648].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[648].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[648].bump_multiplicity(__i); } let __ret: [G; OUT_648] = unsafe { *(record.function_queries[648].output_at(__i).as_ptr() as *const [G; OUT_648]) }; __ret }, _ => aiur_fn_648(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_10, __v_20, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
-            let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_49, __v_10, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_49]; let __cu = unconstrained; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_49]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } };
             let __v_51: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
             let __v_52: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_20]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
             let __v_53: G = __r_arr[0];
             let __v_54: G = G::from_u64(1);
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
@@ -56811,7 +56999,7 @@ fn aiur_fn_672(
             let __v_58: G = (__v_52 * __v_57);
             let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_58.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_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; let __hit = record.function_queries[645].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[645].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[645].bump_multiplicity(__i); } let __ret: [G; OUT_645] = unsafe { *(record.function_queries[645].output_at(__i).as_ptr() as *const [G; OUT_645]) }; __ret }, _ => aiur_fn_645(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_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; let __hit = record.function_queries[650].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[650].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[650].bump_multiplicity(__i); } let __ret: [G; OUT_650] = unsafe { *(record.function_queries[650].output_at(__i).as_ptr() as *const [G; OUT_650]) }; __ret }, _ => aiur_fn_650(__args, record, io_buffer, __cu)? } };
     let __v_59: G = __r_arr[0];
     break '__mc_2 [__v_59];
   },
@@ -56825,26 +57013,26 @@ fn aiur_fn_672(
  };
             let __v_59: G = __mc_out___mc_2[0];
             let __v_60: G = G::from_u64(0);
-            let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[652].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[652].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[652].bump_multiplicity(__i); } let __ret: [G; OUT_652] = unsafe { *(record.function_queries[652].output_at(__i).as_ptr() as *const [G; OUT_652]) }; __ret }, _ => aiur_fn_652(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_49, __v_25, __v_58, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[657].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[657].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[657].bump_multiplicity(__i); } let __ret: [G; OUT_657] = unsafe { *(record.function_queries[657].output_at(__i).as_ptr() as *const [G; OUT_657]) }; __ret }, _ => aiur_fn_657(__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_673] = { let __args: [G; IN_673] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_672] = [];
-                record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_49, __v_62, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_677] = [];
+                record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_63: G = G::from_u64(0);
-                let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[651].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[651].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[651].bump_multiplicity(__i); } let __ret: [G; OUT_651] = unsafe { *(record.function_queries[651].output_at(__i).as_ptr() as *const [G; OUT_651]) }; __ret }, _ => aiur_fn_651(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_49, __v_25, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[656].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[656].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[656].bump_multiplicity(__i); } let __ret: [G; OUT_656] = unsafe { *(record.function_queries[656].output_at(__i).as_ptr() as *const [G; OUT_656]) }; __ret }, _ => aiur_fn_656(__args, record, io_buffer, __cu)? } };
                 let __v_64: G = __r_arr[0];
                 let __v_65: G = __r_arr[1];
                 match __v_64.as_canonical_u64() {
                   1u64 => {
-                    let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_672] = [];
-                    record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_49, __v_65, __v_18, __v_20, __v_21, __v_3, __v_5, __v_6, __v_48, __v_50, __v_51, __v_7, __v_2, __v_15, __v_14, __v_17, __v_46, __v_45]; let __cu = unconstrained; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_677] = [];
+                    record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -56855,8 +57043,8 @@ fn aiur_fn_672(
             }
           },
           _ => {
-            let __ret: [G; OUT_672] = [];
-            record.function_queries[672].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_677] = [];
+            record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -56868,15 +57056,15 @@ fn aiur_fn_672(
   })
 }
 
-const INPUT_SIZE_673: usize = 18;
-const IN_673: usize = 18;
-const OUT_673: usize = 0;
-fn aiur_fn_673(
-  inp: [G; IN_673],
+const INPUT_SIZE_678: usize = 18;
+const IN_678: usize = 18;
+const OUT_678: usize = 0;
+fn aiur_fn_678(
+  inp: [G; IN_678],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_673], ExecError> {
+) -> Result<[G; OUT_678], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56896,27 +57084,27 @@ fn aiur_fn_673(
     let __v_15: G = inp[15];
     let __v_16: G = inp[16];
     let __v_17: G = inp[17];
-    let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[653].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[653].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[653].bump_multiplicity(__i); } let __ret: [G; OUT_653] = unsafe { *(record.function_queries[653].output_at(__i).as_ptr() as *const [G; OUT_653]) }; __ret }, _ => aiur_fn_653(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
     let __v_21: G = __r_arr[3];
-    let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[670].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[670].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[670].bump_multiplicity(__i); } let __ret: [G; OUT_670] = unsafe { *(record.function_queries[670].output_at(__i).as_ptr() as *const [G; OUT_670]) }; __ret }, _ => aiur_fn_670(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_13, __v_14, __v_5, __v_15, __v_16, __v_17, __v_0, __v_10, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_12, __v_22, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_12, __v_22, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__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("recursor's declared type is not def-eq to the canonical reconstruction".to_string()) });
     }
-    let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[789].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[789].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { *(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789]) }; __ret }, _ => aiur_fn_789(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[794].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[794].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { *(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794]) }; __ret }, _ => aiur_fn_794(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
-    let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_10, __v_5, __v_28, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[685].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[685].bump_multiplicity(__i); } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => aiur_fn_685(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_0, __v_10, __v_5, __v_28, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } };
     let __v_29: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_30: G = __r_arr[0];
     if (__v_6 != __v_28) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_28.as_canonical_u64(), msg: Some("recursor motive count disagrees with the canonical reconstruction".to_string()) });
@@ -56925,28 +57113,28 @@ fn aiur_fn_673(
       return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_30.as_canonical_u64(), msg: Some("recursor minor count disagrees with the canonical reconstruction".to_string()) });
     }
     let __v_31: G = G::from_u64(0);
-    let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_1, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_0, __v_1, __v_31]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__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_675] = { let __args: [G; IN_675] = [__v_2, __v_32, __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_33]; let __cu = unconstrained; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_2, __v_32, __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_33]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
     let __v_35: G = G::from_u64(0);
-    let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_11, __v_34, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_673] = [];
-    record.function_queries[673].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_11, __v_34, __v_5, __v_6, __v_7, __v_3, __v_4, __v_2, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_678] = [];
+    record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_674: usize = 3;
-const IN_674: usize = 3;
-const OUT_674: usize = 1;
-fn aiur_fn_674(
-  inp: [G; IN_674],
+const INPUT_SIZE_679: usize = 3;
+const IN_679: usize = 3;
+const OUT_679: usize = 1;
+fn aiur_fn_679(
+  inp: [G; IN_679],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_674], ExecError> {
+) -> Result<[G; OUT_679], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -56955,8 +57143,8 @@ fn aiur_fn_674(
     match __v_3.as_canonical_u64() {
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_674] = [__v_4];
-        record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_679] = [__v_4];
+        record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -56970,12 +57158,12 @@ fn aiur_fn_674(
         match __v_4.as_canonical_u64() {
           1u64 => {
             let __v_10: G = G::from_u64(0);
-            let __ret: [G; OUT_674] = [__v_10];
-            record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_679] = [__v_10];
+            record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_11: G = __loaded[0];
@@ -57003,11 +57191,11 @@ fn aiur_fn_674(
             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_674] = { let __args: [G; IN_674] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_9, __v_1, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__args, record, io_buffer, __cu)? } };
             let __v_26: G = __r_arr[0];
             let __v_27: G = (__v_23 + __v_26);
-            let __ret: [G; OUT_674] = [__v_27];
-            record.function_queries[674].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_679] = [__v_27];
+            record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -57019,15 +57207,15 @@ fn aiur_fn_674(
   })
 }
 
-const INPUT_SIZE_675: usize = 15;
-const IN_675: usize = 15;
-const OUT_675: usize = 1;
-fn aiur_fn_675(
-  inp: [G; IN_675],
+const INPUT_SIZE_680: usize = 15;
+const IN_680: usize = 15;
+const OUT_680: usize = 1;
+fn aiur_fn_680(
+  inp: [G; IN_680],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_675], ExecError> {
+) -> Result<[G; OUT_680], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57050,12 +57238,12 @@ fn aiur_fn_675(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_675] = [__v_18];
-        record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_680] = [__v_18];
+        record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_2, __v_3, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
@@ -57073,24 +57261,24 @@ fn aiur_fn_675(
         match __v_17.as_canonical_u64() {
           6u64 => {
             let __v_29: G = (__v_1 + __v_14);
-            let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__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; let __hit = record.function_queries[678].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[678].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[678].bump_multiplicity(__i); } let __ret: [G; OUT_678] = unsafe { *(record.function_queries[678].output_at(__i).as_ptr() as *const [G; OUT_678]) }; __ret }, _ => aiur_fn_678(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__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; let __hit = record.function_queries[683].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[683].bump_multiplicity(__i); } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => aiur_fn_683(__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_675] = { let __args: [G; IN_675] = [__v_0, __v_1, __v_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; let __hit = record.function_queries[675].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[675].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[675].bump_multiplicity(__i); } let __ret: [G; OUT_675] = unsafe { *(record.function_queries[675].output_at(__i).as_ptr() as *const [G; OUT_675]) }; __ret }, _ => aiur_fn_675(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_0, __v_1, __v_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; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_675] = [__v_35];
-            record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_680] = [__v_35];
+            record.function_queries[680].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_675] = [__v_31];
-            record.function_queries[675].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_680] = [__v_31];
+            record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -57099,15 +57287,15 @@ fn aiur_fn_675(
   })
 }
 
-const INPUT_SIZE_676: usize = 9;
-const IN_676: usize = 9;
-const OUT_676: usize = 0;
-fn aiur_fn_676(
-  inp: [G; IN_676],
+const INPUT_SIZE_681: usize = 9;
+const IN_681: usize = 9;
+const OUT_681: usize = 0;
+fn aiur_fn_681(
+  inp: [G; IN_681],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_676], ExecError> {
+) -> Result<[G; OUT_681], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57126,8 +57314,8 @@ fn aiur_fn_676(
     let __v_13: G = __loaded[4];
     match __v_9.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_676] = [];
-        record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_681] = [];
+        record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -57141,7 +57329,7 @@ fn aiur_fn_676(
             if (__v_14 != __v_15) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_15.as_canonical_u64(), msg: Some("recursor rule names a ctor index out of range".to_string()) });
             }
-            let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_5, __v_6, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_17: G = __loaded[0];
@@ -57174,8 +57362,8 @@ fn aiur_fn_676(
             let __v_31: G = __loaded[2];
             match __v_29.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_676] = [];
-                record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_681] = [];
+                record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               0u64 => {
@@ -57186,7 +57374,7 @@ fn aiur_fn_676(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_12, __v_34, __v_35, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__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];
@@ -57196,7 +57384,7 @@ fn aiur_fn_676(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[438].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[438].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[438].bump_multiplicity(__i); } let __ret: [G; OUT_438] = unsafe { *(record.function_queries[438].output_at(__i).as_ptr() as *const [G; OUT_438]) }; __ret }, _ => aiur_fn_438(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_39, __v_30, __v_44]; let __cu = unconstrained; let __hit = record.function_queries[443].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[443].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[443].bump_multiplicity(__i); } let __ret: [G; OUT_443] = unsafe { *(record.function_queries[443].output_at(__i).as_ptr() as *const [G; OUT_443]) }; __ret }, _ => aiur_fn_443(__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) {
@@ -57204,9 +57392,9 @@ fn aiur_fn_676(
                 }
                 let __v_47: G = G::from_u64(1);
                 let __v_48: G = (__v_8 + __v_47);
-                let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[676].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[676].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[676].bump_multiplicity(__i); } let __ret: [G; OUT_676] = unsafe { *(record.function_queries[676].output_at(__i).as_ptr() as *const [G; OUT_676]) }; __ret }, _ => aiur_fn_676(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_676] = [];
-                record.function_queries[676].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_13, __v_31, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_681] = [];
+                record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -57223,15 +57411,15 @@ fn aiur_fn_676(
   })
 }
 
-const INPUT_SIZE_677: usize = 12;
-const IN_677: usize = 12;
-const OUT_677: usize = 1;
-fn aiur_fn_677(
-  inp: [G; IN_677],
+const INPUT_SIZE_682: usize = 12;
+const IN_682: usize = 12;
+const OUT_682: usize = 1;
+fn aiur_fn_682(
+  inp: [G; IN_682],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_677], ExecError> {
+) -> Result<[G; OUT_682], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57251,13 +57439,13 @@ fn aiur_fn_677(
     let __v_14: G = __loaded[2];
     match __v_12.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_677] = [__v_0];
-        record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_682] = [__v_0];
+        record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_2, __v_11, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__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);
@@ -57292,27 +57480,27 @@ fn aiur_fn_677(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_4, __v_16, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__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_767] = { let __args: [G; IN_767] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_5, __v_16, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__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_777] = { let __args: [G; IN_777] = [__v_3, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_3, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_358] = { let __args: [G; IN_358] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_56, __v_57, __v_58]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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_358] = { let __args: [G; IN_358] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_59, __v_60, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_61: G = __r_arr[0];
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_61]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } };
         let __v_62: G = __r_arr[0];
         let __v_63: G = __r_arr[1];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_62]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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);
@@ -57321,32 +57509,32 @@ fn aiur_fn_677(
         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_668] = { let __args: [G; IN_668] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_68, __v_6, __v_70, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__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_668] = { let __args: [G; IN_668] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_72, __v_7, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__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_668] = { let __args: [G; IN_668] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_77, __v_8, __v_81, __v_82]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_63, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_63, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_87: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_87]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_87]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_88: G = __r_arr[0];
         let __v_89: G = __r_arr[1];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_89, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_89, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_90: G = __r_arr[0];
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_83, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_83, __v_90]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__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);
@@ -57356,22 +57544,22 @@ fn aiur_fn_677(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_99: G = G::from_u64(0);
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_98, __v_64, __v_99]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_103, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[669].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[669].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[669].bump_multiplicity(__i); } let __ret: [G; OUT_669] = unsafe { *(record.function_queries[669].output_at(__i).as_ptr() as *const [G; OUT_669]) }; __ret }, _ => aiur_fn_669(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_103, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[674].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[674].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[674].bump_multiplicity(__i); } let __ret: [G; OUT_674] = unsafe { *(record.function_queries[674].output_at(__i).as_ptr() as *const [G; OUT_674]) }; __ret }, _ => aiur_fn_674(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_677] = { let __args: [G; IN_677] = [__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; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__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; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } };
         let __v_110: G = __r_arr[0];
-        let __ret: [G; OUT_677] = [__v_110];
-        record.function_queries[677].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_682] = [__v_110];
+        record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -57381,15 +57569,15 @@ fn aiur_fn_677(
   })
 }
 
-const INPUT_SIZE_678: usize = 13;
-const IN_678: usize = 13;
-const OUT_678: usize = 1;
-fn aiur_fn_678(
-  inp: [G; IN_678],
+const INPUT_SIZE_683: usize = 13;
+const IN_683: usize = 13;
+const OUT_683: usize = 1;
+fn aiur_fn_683(
+  inp: [G; IN_683],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_678], ExecError> {
+) -> Result<[G; OUT_683], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57404,19 +57592,19 @@ fn aiur_fn_678(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_0, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_13, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     let __v_15: G = G::from_u64(0);
-    let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => aiur_fn_688(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_14, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } };
     let __v_16: G = __r_arr[0];
     let __v_17: G = (__v_2 + __v_3);
     let __v_18: G = (__v_17 + __v_4);
     let __v_19: G = (__v_18 + __v_16);
     let __v_20: G = G::from_u64(0);
     let __v_21: G = G::from_u64(0);
-    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_5, __v_5, __v_20, __v_11, __v_12, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__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);
@@ -57429,7 +57617,7 @@ fn aiur_fn_678(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_701] = { let __args: [G; IN_701] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_22, __v_8, __v_25, __v_28, __v_31, __v_32, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__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];
@@ -57443,26 +57631,26 @@ fn aiur_fn_678(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_695] = { let __args: [G; IN_695] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_45, __v_16, __v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__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_677] = { let __args: [G; IN_677] = [__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; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__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; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
-    let __ret: [G; OUT_678] = [__v_49];
-    record.function_queries[678].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_683] = [__v_49];
+    record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_679: usize = 3;
-const IN_679: usize = 3;
-const OUT_679: usize = 1;
-fn aiur_fn_679(
-  inp: [G; IN_679],
+const INPUT_SIZE_684: usize = 3;
+const IN_684: usize = 3;
+const OUT_684: usize = 1;
+fn aiur_fn_684(
+  inp: [G; IN_684],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_679], ExecError> {
+) -> Result<[G; OUT_684], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57479,19 +57667,19 @@ fn aiur_fn_679(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_679] = [__v_11];
-        record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_684] = [__v_11];
+        record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[680].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[680].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[680].bump_multiplicity(__i); } let __ret: [G; OUT_680] = unsafe { *(record.function_queries[680].output_at(__i).as_ptr() as *const [G; OUT_680]) }; __ret }, _ => aiur_fn_680(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_1, __v_4, __v_6, __v_5, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[685].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[685].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[685].bump_multiplicity(__i); } let __ret: [G; OUT_685] = unsafe { *(record.function_queries[685].output_at(__i).as_ptr() as *const [G; OUT_685]) }; __ret }, _ => aiur_fn_685(__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_679] = { let __args: [G; IN_679] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[679].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[679].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[679].bump_multiplicity(__i); } let __ret: [G; OUT_679] = unsafe { *(record.function_queries[679].output_at(__i).as_ptr() as *const [G; OUT_679]) }; __ret }, _ => aiur_fn_679(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_8, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_679] = [__v_12];
-        record.function_queries[679].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_684] = [__v_12];
+        record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -57501,22 +57689,22 @@ fn aiur_fn_679(
   })
 }
 
-const INPUT_SIZE_680: usize = 5;
-const IN_680: usize = 5;
-const OUT_680: usize = 1;
-fn aiur_fn_680(
-  inp: [G; IN_680],
+const INPUT_SIZE_685: usize = 5;
+const IN_685: usize = 5;
+const OUT_685: usize = 1;
+fn aiur_fn_685(
+  inp: [G; IN_685],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_680], ExecError> {
+) -> Result<[G; OUT_685], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     let __v_3: G = inp[3];
     let __v_4: G = inp[4];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -57570,15 +57758,15 @@ fn aiur_fn_680(
         match __v_5.as_canonical_u64() {
           8u64 => {
             let __v_53: G = G::from_u64(0);
-            let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_6, __v_6, __v_0, __v_1, __v_2, __v_3, __v_4, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } };
             let __v_54: G = __r_arr[0];
-            let __ret: [G; OUT_680] = [__v_54];
-            record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_685] = [__v_54];
+            record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_680] = [__v_4];
-            record.function_queries[680].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_685] = [__v_4];
+            record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -57587,15 +57775,15 @@ fn aiur_fn_680(
   })
 }
 
-const INPUT_SIZE_681: usize = 8;
-const IN_681: usize = 8;
-const OUT_681: usize = 1;
-fn aiur_fn_681(
-  inp: [G; IN_681],
+const INPUT_SIZE_686: usize = 8;
+const IN_686: usize = 8;
+const OUT_686: usize = 1;
+fn aiur_fn_686(
+  inp: [G; IN_686],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_681], ExecError> {
+) -> Result<[G; OUT_686], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57655,16 +57843,16 @@ fn aiur_fn_681(
     let __v_54: G = __loaded[46];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_681] = [__v_6];
-        record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_686] = [__v_6];
+        record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_9.as_canonical_u64() {
           2u64 => {
-            let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_0, __v_2, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
             let __v_55: G = __r_arr[0];
-            let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_55]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
             let __v_57: G = __loaded[0];
@@ -57681,9 +57869,9 @@ fn aiur_fn_681(
             let __v_68: G = __loaded[11];
             let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_57.as_canonical_u64() {
   7u64 => {
-    let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_59, __v_60, __v_62, __v_63, __v_61]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
     let __v_69: G = __r_arr[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_69]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_71: G = __loaded[0];
@@ -57719,9 +57907,9 @@ fn aiur_fn_681(
             break '__mc_0 [__v_85];
           },
           _ => {
-            let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[636].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[636].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[636].bump_multiplicity(__i); } let __ret: [G; OUT_636] = unsafe { *(record.function_queries[636].output_at(__i).as_ptr() as *const [G; OUT_636]) }; __ret }, _ => aiur_fn_636(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_59, __v_60, __v_62, __v_63, __v_61, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[641].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[641].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[641].bump_multiplicity(__i); } let __ret: [G; OUT_641] = unsafe { *(record.function_queries[641].output_at(__i).as_ptr() as *const [G; OUT_641]) }; __ret }, _ => aiur_fn_641(__args, record, io_buffer, __cu)? } };
             let __v_85: G = __r_arr[0];
-            let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_85, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[644].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[644].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[644].bump_multiplicity(__i); } let __ret: [G; OUT_644] = unsafe { *(record.function_queries[644].output_at(__i).as_ptr() as *const [G; OUT_644]) }; __ret }, _ => aiur_fn_644(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_85, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[649].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[649].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[649].bump_multiplicity(__i); } let __ret: [G; OUT_649] = unsafe { *(record.function_queries[649].output_at(__i).as_ptr() as *const [G; OUT_649]) }; __ret }, _ => aiur_fn_649(__args, record, io_buffer, __cu)? } };
             let __v_86: G = __r_arr[0];
             break '__mc_0 [__v_86];
           },
@@ -57742,17 +57930,17 @@ fn aiur_fn_681(
             let __v_69: G = __mc_out___mc_0[0];
             match __v_69.as_canonical_u64() {
               1u64 => {
-                let __ret: [G; OUT_681] = [__v_55];
-                record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_686] = [__v_55];
+                record.function_queries[686].finish(&inp[..], &__ret[..], !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_681] = { let __args: [G; IN_681] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_71]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } };
                 let __v_72: G = __r_arr[0];
-                let __ret: [G; OUT_681] = [__v_72];
-                record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_686] = [__v_72];
+                record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -57760,10 +57948,10 @@ fn aiur_fn_681(
           _ => {
             let __v_55: G = G::from_u64(1);
             let __v_56: G = (__v_7 + __v_55);
-            let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[681].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[681].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[681].bump_multiplicity(__i); } let __ret: [G; OUT_681] = unsafe { *(record.function_queries[681].output_at(__i).as_ptr() as *const [G; OUT_681]) }; __ret }, _ => aiur_fn_681(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_54, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } };
             let __v_57: G = __r_arr[0];
-            let __ret: [G; OUT_681] = [__v_57];
-            record.function_queries[681].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_686] = [__v_57];
+            record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -57775,15 +57963,15 @@ fn aiur_fn_681(
   })
 }
 
-const INPUT_SIZE_682: usize = 1;
-const IN_682: usize = 1;
-const OUT_682: usize = 1;
-fn aiur_fn_682(
-  inp: [G; IN_682],
+const INPUT_SIZE_687: usize = 1;
+const IN_687: usize = 1;
+const OUT_687: usize = 1;
+fn aiur_fn_687(
+  inp: [G; IN_687],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_682], ExecError> {
+) -> Result<[G; OUT_687], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
@@ -57798,12 +57986,12 @@ fn aiur_fn_682(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_682] = [__v_9];
-        record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_687] = [__v_9];
+        record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_8: G = __loaded[0];
@@ -57830,11 +58018,11 @@ fn aiur_fn_682(
  };
         let __v_20: G = __mc_out___mc_0[0];
         let __v_21: G = G::from_u64(0);
-        let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[682].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[682].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[682].bump_multiplicity(__i); } let __ret: [G; OUT_682] = unsafe { *(record.function_queries[682].output_at(__i).as_ptr() as *const [G; OUT_682]) }; __ret }, _ => aiur_fn_682(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_682] = [__v_23];
-        record.function_queries[682].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_687] = [__v_23];
+        record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -57844,20 +58032,20 @@ fn aiur_fn_682(
   })
 }
 
-const INPUT_SIZE_683: usize = 3;
-const IN_683: usize = 3;
-const OUT_683: usize = 1;
-fn aiur_fn_683(
-  inp: [G; IN_683],
+const INPUT_SIZE_688: usize = 3;
+const IN_688: usize = 3;
+const OUT_688: usize = 1;
+fn aiur_fn_688(
+  inp: [G; IN_688],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_683], ExecError> {
+) -> Result<[G; OUT_688], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__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];
@@ -57866,7 +58054,7 @@ fn aiur_fn_683(
     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_293] = { let __args: [G; IN_293] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[293].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[293].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[293].bump_multiplicity(__i); } let __ret: [G; OUT_293] = unsafe { *(record.function_queries[293].output_at(__i).as_ptr() as *const [G; OUT_293]) }; __ret }, _ => aiur_fn_293(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[298].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[298].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[298].bump_multiplicity(__i); } let __ret: [G; OUT_298] = unsafe { *(record.function_queries[298].output_at(__i).as_ptr() as *const [G; OUT_298]) }; __ret }, _ => aiur_fn_298(__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];
@@ -57889,25 +58077,25 @@ fn aiur_fn_683(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_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; let __hit = record.function_queries[73].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[73].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[73].bump_multiplicity(__i); } let __ret: [G; OUT_73] = unsafe { *(record.function_queries[73].output_at(__i).as_ptr() as *const [G; OUT_73]) }; __ret }, _ => aiur_fn_73(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__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; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_33]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_34: G = __r_arr[0];
-    let __ret: [G; OUT_683] = [__v_34];
-    record.function_queries[683].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_688] = [__v_34];
+    record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_684: usize = 15;
-const IN_684: usize = 15;
-const OUT_684: usize = 1;
-fn aiur_fn_684(
-  inp: [G; IN_684],
+const INPUT_SIZE_689: usize = 15;
+const IN_689: usize = 15;
+const OUT_689: usize = 1;
+fn aiur_fn_689(
+  inp: [G; IN_689],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_684], ExecError> {
+) -> Result<[G; OUT_689], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57930,12 +58118,12 @@ fn aiur_fn_684(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_684] = [__v_18];
-        record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_689] = [__v_18];
+        record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[290].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[290].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[290].bump_multiplicity(__i); } let __ret: [G; OUT_290] = unsafe { *(record.function_queries[290].output_at(__i).as_ptr() as *const [G; OUT_290]) }; __ret }, _ => aiur_fn_290(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = [__v_10, __v_11, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[295].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[295].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[295].bump_multiplicity(__i); } let __ret: [G; OUT_295] = unsafe { *(record.function_queries[295].output_at(__i).as_ptr() as *const [G; OUT_295]) }; __ret }, _ => aiur_fn_295(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_17: G = __loaded[0];
@@ -57952,20 +58140,20 @@ fn aiur_fn_684(
         let __v_28: G = __loaded[11];
         match __v_17.as_canonical_u64() {
           6u64 => {
-            let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[683].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[683].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[683].bump_multiplicity(__i); } let __ret: [G; OUT_683] = unsafe { *(record.function_queries[683].output_at(__i).as_ptr() as *const [G; OUT_683]) }; __ret }, _ => aiur_fn_683(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_11, __v_14, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => aiur_fn_688(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
-            let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__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; let __hit = record.function_queries[690].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[690].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[690].bump_multiplicity(__i); } let __ret: [G; OUT_690] = unsafe { *(record.function_queries[690].output_at(__i).as_ptr() as *const [G; OUT_690]) }; __ret }, _ => aiur_fn_690(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__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; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__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_684] = { let __args: [G; IN_684] = [__v_0, __v_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; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_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; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_684] = [__v_37];
-            record.function_queries[684].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_689] = [__v_37];
+            record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -57977,15 +58165,15 @@ fn aiur_fn_684(
   })
 }
 
-const INPUT_SIZE_685: usize = 5;
-const IN_685: usize = 5;
-const OUT_685: usize = 1;
-fn aiur_fn_685(
-  inp: [G; IN_685],
+const INPUT_SIZE_690: usize = 5;
+const IN_690: usize = 5;
+const OUT_690: usize = 1;
+fn aiur_fn_690(
+  inp: [G; IN_690],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_685], ExecError> {
+) -> Result<[G; OUT_690], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -57994,23 +58182,23 @@ fn aiur_fn_685(
     let __v_4: G = inp[4];
     let __v_5: G = G::from_u64(0);
     let __v_6: G = G::from_u64(0);
-    let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_0, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } };
     let __v_7: G = __r_arr[0];
-    let __ret: [G; OUT_685] = [__v_7];
-    record.function_queries[685].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_690] = [__v_7];
+    record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_686: usize = 8;
-const IN_686: usize = 8;
-const OUT_686: usize = 1;
-fn aiur_fn_686(
-  inp: [G; IN_686],
+const INPUT_SIZE_691: usize = 8;
+const IN_691: usize = 8;
+const OUT_691: usize = 1;
+fn aiur_fn_691(
+  inp: [G; IN_691],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_686], ExecError> {
+) -> Result<[G; OUT_691], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58032,12 +58220,12 @@ fn aiur_fn_686(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_686] = [__v_16];
-        record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_691] = [__v_16];
+        record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_15: G = __loaded[0];
@@ -58055,28 +58243,28 @@ fn aiur_fn_686(
         match __v_15.as_canonical_u64() {
           5u64 => {
             let __v_27: G = G::from_u64(0);
-            let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__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; let __hit = record.function_queries[684].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[684].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[684].bump_multiplicity(__i); } let __ret: [G; OUT_684] = unsafe { *(record.function_queries[684].output_at(__i).as_ptr() as *const [G; OUT_684]) }; __ret }, _ => aiur_fn_684(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__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; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
-            let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_686] = { let __args: [G; IN_686] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_30, __v_32]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } };
             let __v_33: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_28, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_28, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
-            let __ret: [G; OUT_686] = [__v_34];
-            record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_691] = [__v_34];
+            record.function_queries[691].finish(&inp[..], &__ret[..], !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_686] = { let __args: [G; IN_686] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[686].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[686].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[686].bump_multiplicity(__i); } let __ret: [G; OUT_686] = unsafe { *(record.function_queries[686].output_at(__i).as_ptr() as *const [G; OUT_686]) }; __ret }, _ => aiur_fn_686(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } };
             let __v_29: G = __r_arr[0];
-            let __ret: [G; OUT_686] = [__v_29];
-            record.function_queries[686].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_691] = [__v_29];
+            record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -58088,15 +58276,15 @@ fn aiur_fn_686(
   })
 }
 
-const INPUT_SIZE_687: usize = 5;
-const IN_687: usize = 5;
-const OUT_687: usize = 1;
-fn aiur_fn_687(
-  inp: [G; IN_687],
+const INPUT_SIZE_692: usize = 5;
+const IN_692: usize = 5;
+const OUT_692: usize = 1;
+fn aiur_fn_692(
+  inp: [G; IN_692],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_687], ExecError> {
+) -> Result<[G; OUT_692], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58111,23 +58299,23 @@ fn aiur_fn_687(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_687] = [__v_10];
-        record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_692] = [__v_10];
+        record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_6.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_4, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_358] = { let __args: [G; IN_358] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_7, __v_2, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
             let __v_9: G = __r_arr[0];
-            let __ret: [G; OUT_687] = [__v_9];
-            record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_692] = [__v_9];
+            record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -58137,8 +58325,8 @@ fn aiur_fn_687(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_687] = [__v_12];
-            record.function_queries[687].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_692] = [__v_12];
+            record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -58147,15 +58335,15 @@ fn aiur_fn_687(
   })
 }
 
-const INPUT_SIZE_688: usize = 2;
-const IN_688: usize = 2;
-const OUT_688: usize = 1;
-fn aiur_fn_688(
-  inp: [G; IN_688],
+const INPUT_SIZE_693: usize = 2;
+const IN_693: usize = 2;
+const OUT_693: usize = 1;
+fn aiur_fn_693(
+  inp: [G; IN_693],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_688], ExecError> {
+) -> Result<[G; OUT_693], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58168,30 +58356,30 @@ fn aiur_fn_688(
       5u64 => {
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_1 + __v_6);
-        let __r_arr: [G; OUT_688] = { let __args: [G; IN_688] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[688].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[688].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[688].bump_multiplicity(__i); } let __ret: [G; OUT_688] = unsafe { *(record.function_queries[688].output_at(__i).as_ptr() as *const [G; OUT_688]) }; __ret }, _ => aiur_fn_688(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
-        let __ret: [G; OUT_688] = [__v_8];
-        record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_693] = [__v_8];
+        record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_688] = [__v_1];
-        record.function_queries[688].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_693] = [__v_1];
+        record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_689: usize = 7;
-const IN_689: usize = 7;
-const OUT_689: usize = 1;
-fn aiur_fn_689(
-  inp: [G; IN_689],
+const INPUT_SIZE_694: usize = 7;
+const IN_694: usize = 7;
+const OUT_694: usize = 1;
+fn aiur_fn_694(
+  inp: [G; IN_694],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_689], ExecError> {
+) -> Result<[G; OUT_694], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58202,8 +58390,8 @@ fn aiur_fn_689(
     let __v_6: G = inp[6];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_689] = [__v_0];
-        record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_694] = [__v_0];
+        record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -58214,26 +58402,26 @@ fn aiur_fn_689(
         let __v_10: G = __loaded[3];
         match __v_7.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__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_367] = { let __args: [G; IN_367] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_9, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
             let __v_14: G = G::from_u64(1);
             let __v_15: G = (__v_1 - __v_14);
             let __v_16: G = G::from_u64(1);
             let __v_17: G = (__v_6 + __v_16);
-            let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_15, __v_2, __v_3, __v_4, __v_5, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
-            let __ret: [G; OUT_689] = [__v_18];
-            record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_694] = [__v_18];
+            record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_11: G = G::from_u64(1);
             let __v_12: G = G::from_u64(1);
             let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
             let __v_15: G = __loaded[0];
@@ -58242,19 +58430,19 @@ fn aiur_fn_689(
             let __v_18: G = __loaded[3];
             match __v_15.as_canonical_u64() {
               5u64 => {
-                let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[687].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[687].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[687].bump_multiplicity(__i); } let __ret: [G; OUT_687] = unsafe { *(record.function_queries[687].output_at(__i).as_ptr() as *const [G; OUT_687]) }; __ret }, _ => aiur_fn_687(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__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_367] = { let __args: [G; IN_367] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[367].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[367].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[367].bump_multiplicity(__i); } let __ret: [G; OUT_367] = unsafe { *(record.function_queries[367].output_at(__i).as_ptr() as *const [G; OUT_367]) }; __ret }, _ => aiur_fn_367(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[372].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[372].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[372].bump_multiplicity(__i); } let __ret: [G; OUT_372] = unsafe { *(record.function_queries[372].output_at(__i).as_ptr() as *const [G; OUT_372]) }; __ret }, _ => aiur_fn_372(__args, record, io_buffer, __cu)? } };
                 let __v_21: G = __r_arr[0];
                 let __v_22: G = G::from_u64(1);
                 let __v_23: G = (__v_1 - __v_22);
                 let __v_24: G = G::from_u64(1);
                 let __v_25: G = (__v_6 + __v_24);
-                let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_21, __v_23, __v_2, __v_3, __v_4, __v_5, __v_25]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } };
                 let __v_26: G = __r_arr[0];
-                let __ret: [G; OUT_689] = [__v_26];
-                record.function_queries[689].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_694] = [__v_26];
+                record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -58268,15 +58456,15 @@ fn aiur_fn_689(
   })
 }
 
-const INPUT_SIZE_690: usize = 13;
-const IN_690: usize = 13;
-const OUT_690: usize = 1;
-fn aiur_fn_690(
-  inp: [G; IN_690],
+const INPUT_SIZE_695: usize = 13;
+const IN_695: usize = 13;
+const OUT_695: usize = 1;
+fn aiur_fn_695(
+  inp: [G; IN_695],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_690], ExecError> {
+) -> Result<[G; OUT_695], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58291,13 +58479,13 @@ fn aiur_fn_690(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[336].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[336].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[336].bump_multiplicity(__i); } let __ret: [G; OUT_336] = unsafe { *(record.function_queries[336].output_at(__i).as_ptr() as *const [G; OUT_336]) }; __ret }, _ => aiur_fn_336(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_1, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[341].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[341].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[341].bump_multiplicity(__i); } let __ret: [G; OUT_341] = unsafe { *(record.function_queries[341].output_at(__i).as_ptr() as *const [G; OUT_341]) }; __ret }, _ => aiur_fn_341(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     let __v_14: G = (__v_9 + __v_10);
     let __v_15: G = (__v_8 + __v_14);
     let __v_16: G = (__v_9 + __v_10);
     let __v_17: G = G::from_u64(0);
-    let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[689].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[689].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[689].bump_multiplicity(__i); } let __ret: [G; OUT_689] = unsafe { *(record.function_queries[689].output_at(__i).as_ptr() as *const [G; OUT_689]) }; __ret }, _ => aiur_fn_689(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_13, __v_2, __v_15, __v_16, __v_3, __v_4, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__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);
@@ -58309,24 +58497,24 @@ fn aiur_fn_690(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_701] = { let __args: [G; IN_701] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_18, __v_6, __v_21, __v_24, __v_27, __v_28, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__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_775] = { let __args: [G; IN_775] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
     let __v_33: G = __r_arr[0];
-    let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_30]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_115] = { let __args: [G; IN_115] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_32]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
-    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_38, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_38, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
     let __v_39: G = __r_arr[0];
     let __v_40: G = G::from_u64(0);
-    let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_39, __v_34, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__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);
@@ -58335,66 +58523,66 @@ fn aiur_fn_690(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_48, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_48, __v_41]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
     let __v_49: G = __r_arr[0];
     let __v_50: G = G::from_u64(2);
     let __v_51: G = G::from_u64(0);
     let __v_52: G = { let __values: [G; 4] = [__v_50, __v_0, __v_5, __v_51]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_52, __v_2, __v_8, __v_36, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__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_695] = { let __args: [G; IN_695] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_53, __v_33, __v_35, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_693] = { let __args: [G; IN_693] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_30, __v_31, __v_29, __v_7, __v_11, __v_33, __v_15, __v_59]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } };
     let __v_60: G = __r_arr[0];
-    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_58, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_58, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
     let __v_61: G = __r_arr[0];
-    let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_61, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_61, __v_29]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
     let __v_62: G = __r_arr[0];
-    let __ret: [G; OUT_690] = [__v_62];
-    record.function_queries[690].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_695] = [__v_62];
+    record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_691: usize = 1;
-const IN_691: usize = 1;
-const OUT_691: usize = 2;
-fn aiur_fn_691(
-  inp: [G; IN_691],
+const INPUT_SIZE_696: usize = 1;
+const IN_696: usize = 1;
+const OUT_696: usize = 2;
+fn aiur_fn_696(
+  inp: [G; IN_696],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_691], ExecError> {
+) -> Result<[G; OUT_696], 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
     let __v_6: G = __r_arr[0];
-    let __ret: [G; OUT_691] = [__v_6, __v_5];
-    record.function_queries[691].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_696] = [__v_6, __v_5];
+    record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_692: usize = 2;
-const IN_692: usize = 2;
-const OUT_692: usize = 2;
-fn aiur_fn_692(
-  inp: [G; IN_692],
+const INPUT_SIZE_697: usize = 2;
+const IN_697: usize = 2;
+const OUT_697: usize = 2;
+fn aiur_fn_697(
+  inp: [G; IN_697],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_692], ExecError> {
+) -> Result<[G; OUT_697], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58407,31 +58595,31 @@ fn aiur_fn_692(
       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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[692].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[692].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[692].bump_multiplicity(__i); } let __ret: [G; OUT_692] = unsafe { *(record.function_queries[692].output_at(__i).as_ptr() as *const [G; OUT_692]) }; __ret }, _ => aiur_fn_692(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } };
         let __v_8: G = __r_arr[0];
         let __v_9: G = __r_arr[1];
-        let __ret: [G; OUT_692] = [__v_8, __v_9];
-        record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_697] = [__v_8, __v_9];
+        record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __ret: [G; OUT_692] = [__v_1, __v_0];
-        record.function_queries[692].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_697] = [__v_1, __v_0];
+        record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_693: usize = 8;
-const IN_693: usize = 8;
-const OUT_693: usize = 1;
-fn aiur_fn_693(
-  inp: [G; IN_693],
+const INPUT_SIZE_698: usize = 8;
+const IN_698: usize = 8;
+const OUT_698: usize = 1;
+fn aiur_fn_698(
+  inp: [G; IN_698],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_693], ExecError> {
+) -> Result<[G; OUT_698], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58450,30 +58638,30 @@ fn aiur_fn_693(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_693] = [__v_13];
-        record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_698] = [__v_13];
+        record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_1, __v_7, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__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_767] = { let __args: [G; IN_767] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_3, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__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_777] = { let __args: [G; IN_777] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__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_358] = { let __args: [G; IN_358] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_17, __v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_691] = { let __args: [G; IN_691] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[691].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[691].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[691].bump_multiplicity(__i); } let __ret: [G; OUT_691] = unsafe { *(record.function_queries[691].output_at(__i).as_ptr() as *const [G; OUT_691]) }; __ret }, _ => aiur_fn_691(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_21]; let __cu = unconstrained; let __hit = record.function_queries[696].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[696].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[696].bump_multiplicity(__i); } let __ret: [G; OUT_696] = unsafe { *(record.function_queries[696].output_at(__i).as_ptr() as *const [G; OUT_696]) }; __ret }, _ => aiur_fn_696(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
         let __v_23: G = __r_arr[1];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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);
@@ -58487,37 +58675,37 @@ fn aiur_fn_693(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_23, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_23, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__args, record, io_buffer, __cu)? } };
         let __v_37: G = __r_arr[0];
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_38: G = __r_arr[0];
         let __v_39: G = __r_arr[1];
-        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_39, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_39, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
         let __v_40: G = __r_arr[0];
         let __v_41: G = G::from_u64(0);
         let __v_42: G = G::from_u64(0);
         let __v_43: G = { let __values: [G; 4] = [__v_41, __v_29, __v_42, __v_42]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = [__v_43, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[255].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[255].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[255].bump_multiplicity(__i); } let __ret: [G; OUT_255] = unsafe { *(record.function_queries[255].output_at(__i).as_ptr() as *const [G; OUT_255]) }; __ret }, _ => aiur_fn_255(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = [__v_43, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[260].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[260].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[260].bump_multiplicity(__i); } let __ret: [G; OUT_260] = unsafe { *(record.function_queries[260].output_at(__i).as_ptr() as *const [G; OUT_260]) }; __ret }, _ => aiur_fn_260(__args, record, io_buffer, __cu)? } };
         let __v_44: G = __r_arr[0];
         let __v_45: G = G::from_u64(0);
         let __v_46: G = G::from_u64(0);
         let __v_47: G = { let __values: [G; 4] = [__v_45, __v_33, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_48: G = G::from_u64(0);
-        let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[660].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[660].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[660].bump_multiplicity(__i); } let __ret: [G; OUT_660] = unsafe { *(record.function_queries[660].output_at(__i).as_ptr() as *const [G; OUT_660]) }; __ret }, _ => aiur_fn_660(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_47, __v_24, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[665].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[665].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[665].bump_multiplicity(__i); } let __ret: [G; OUT_665] = unsafe { *(record.function_queries[665].output_at(__i).as_ptr() as *const [G; OUT_665]) }; __ret }, _ => aiur_fn_665(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_52, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[661].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[661].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[661].bump_multiplicity(__i); } let __ret: [G; OUT_661] = unsafe { *(record.function_queries[661].output_at(__i).as_ptr() as *const [G; OUT_661]) }; __ret }, _ => aiur_fn_661(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_52, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__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_693] = { let __args: [G; IN_693] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[693].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[693].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[693].bump_multiplicity(__i); } let __ret: [G; OUT_693] = unsafe { *(record.function_queries[693].output_at(__i).as_ptr() as *const [G; OUT_693]) }; __ret }, _ => aiur_fn_693(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_56]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_693] = [__v_58];
-        record.function_queries[693].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_698] = [__v_58];
+        record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -58527,15 +58715,15 @@ fn aiur_fn_693(
   })
 }
 
-const INPUT_SIZE_694: usize = 3;
-const IN_694: usize = 3;
-const OUT_694: usize = 1;
-fn aiur_fn_694(
-  inp: [G; IN_694],
+const INPUT_SIZE_699: usize = 3;
+const IN_699: usize = 3;
+const OUT_699: usize = 1;
+fn aiur_fn_699(
+  inp: [G; IN_699],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_694], ExecError> {
+) -> Result<[G; OUT_699], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58549,19 +58737,19 @@ fn aiur_fn_694(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_694] = [__v_8];
-        record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_699] = [__v_8];
+        record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[694].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[694].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[694].bump_multiplicity(__i); } let __ret: [G; OUT_694] = unsafe { *(record.function_queries[694].output_at(__i).as_ptr() as *const [G; OUT_694]) }; __ret }, _ => aiur_fn_694(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_694] = [__v_9];
-        record.function_queries[694].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_699] = [__v_9];
+        record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -58571,15 +58759,15 @@ fn aiur_fn_694(
   })
 }
 
-const INPUT_SIZE_695: usize = 4;
-const IN_695: usize = 4;
-const OUT_695: usize = 1;
-fn aiur_fn_695(
-  inp: [G; IN_695],
+const INPUT_SIZE_700: usize = 4;
+const IN_700: usize = 4;
+const OUT_700: usize = 1;
+fn aiur_fn_700(
+  inp: [G; IN_700],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_695], ExecError> {
+) -> Result<[G; OUT_700], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58588,8 +58776,8 @@ fn aiur_fn_695(
     let __v_4: G = (__v_1 - __v_3);
     match __v_4.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_695] = [__v_0];
-        record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_700] = [__v_0];
+        record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -58604,25 +58792,25 @@ fn aiur_fn_695(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
         let __v_14: G = G::from_u64(1);
         let __v_15: G = (__v_3 + __v_14);
-        let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[695].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[695].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[695].bump_multiplicity(__i); } let __ret: [G; OUT_695] = unsafe { *(record.function_queries[695].output_at(__i).as_ptr() as *const [G; OUT_695]) }; __ret }, _ => aiur_fn_695(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
-        let __ret: [G; OUT_695] = [__v_16];
-        record.function_queries[695].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_700] = [__v_16];
+        record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_696: usize = 6;
-const IN_696: usize = 6;
-const OUT_696: usize = 1;
-fn aiur_fn_696(
-  inp: [G; IN_696],
+const INPUT_SIZE_701: usize = 6;
+const IN_701: usize = 6;
+const OUT_701: usize = 1;
+fn aiur_fn_701(
+  inp: [G; IN_701],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_696], ExecError> {
+) -> Result<[G; OUT_701], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58635,55 +58823,55 @@ fn aiur_fn_696(
         let __v_6: G = G::from_u64(1);
         let __v_7: G = (__v_3 - __v_6);
         let __v_8: G = G::from_u64(0);
-        let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[668].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[668].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[668].bump_multiplicity(__i); } let __ret: [G; OUT_668] = unsafe { *(record.function_queries[668].output_at(__i).as_ptr() as *const [G; OUT_668]) }; __ret }, _ => aiur_fn_668(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[673].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[673].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[673].bump_multiplicity(__i); } let __ret: [G; OUT_673] = unsafe { *(record.function_queries[673].output_at(__i).as_ptr() as *const [G; OUT_673]) }; __ret }, _ => aiur_fn_673(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __ret: [G; OUT_696] = [__v_9];
-        record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_701] = [__v_9];
+        record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __v_6: G = (__v_3 - __v_2);
-        let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[658].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[658].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[658].bump_multiplicity(__i); } let __ret: [G; OUT_658] = unsafe { *(record.function_queries[658].output_at(__i).as_ptr() as *const [G; OUT_658]) }; __ret }, _ => aiur_fn_658(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__v_0, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[663].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[663].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[663].bump_multiplicity(__i); } let __ret: [G; OUT_663] = unsafe { *(record.function_queries[663].output_at(__i).as_ptr() as *const [G; OUT_663]) }; __ret }, _ => aiur_fn_663(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_696] = [__v_7];
-        record.function_queries[696].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_701] = [__v_7];
+        record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_697: usize = 3;
-const IN_697: usize = 3;
-const OUT_697: usize = 2;
-fn aiur_fn_697(
-  inp: [G; IN_697],
+const INPUT_SIZE_702: usize = 3;
+const IN_702: usize = 3;
+const OUT_702: usize = 2;
+fn aiur_fn_702(
+  inp: [G; IN_702],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_697], ExecError> {
+) -> Result<[G; OUT_702], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
-    let __ret: [G; OUT_697] = [__v_3, __v_4];
-    record.function_queries[697].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_702] = [__v_3, __v_4];
+    record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_698: usize = 3;
-const IN_698: usize = 3;
-const OUT_698: usize = 2;
-fn aiur_fn_698(
-  inp: [G; IN_698],
+const INPUT_SIZE_703: usize = 3;
+const IN_703: usize = 3;
+const OUT_703: usize = 2;
+fn aiur_fn_703(
+  inp: [G; IN_703],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_698], ExecError> {
+) -> Result<[G; OUT_703], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58691,7 +58879,7 @@ fn aiur_fn_698(
     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[417].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[417].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[417].bump_multiplicity(__i); } let __ret: [G; OUT_417] = unsafe { *(record.function_queries[417].output_at(__i).as_ptr() as *const [G; OUT_417]) }; __ret }, _ => aiur_fn_417(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[422].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[422].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[422].bump_multiplicity(__i); } let __ret: [G; OUT_422] = unsafe { *(record.function_queries[422].output_at(__i).as_ptr() as *const [G; OUT_422]) }; __ret }, _ => aiur_fn_422(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_7: G = __loaded[0];
@@ -58700,15 +58888,15 @@ fn aiur_fn_698(
     let __v_10: G = __loaded[3];
     match __v_7.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[698].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[698].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[698].bump_multiplicity(__i); } let __ret: [G; OUT_698] = unsafe { *(record.function_queries[698].output_at(__i).as_ptr() as *const [G; OUT_698]) }; __ret }, _ => aiur_fn_698(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_9, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
-        let __ret: [G; OUT_698] = [__v_11, __v_12];
-        record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_703] = [__v_11, __v_12];
+        record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
@@ -58719,18 +58907,18 @@ fn aiur_fn_698(
         match __v_13.as_canonical_u64() {
           2u64 => {
             let __v_17: G = G::from_u64(0);
-            let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_1, __v_14, __v_12, __v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } };
             let __v_18: G = __r_arr[0];
             let __v_19: G = __r_arr[1];
-            let __ret: [G; OUT_698] = [__v_18, __v_19];
-            record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_703] = [__v_18, __v_19];
+            record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_17: G = G::from_u64(0);
             let __v_18: G = G::from_u64(0);
-            let __ret: [G; OUT_698] = [__v_17, __v_18];
-            record.function_queries[698].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_703] = [__v_17, __v_18];
+            record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -58739,15 +58927,15 @@ fn aiur_fn_698(
   })
 }
 
-const INPUT_SIZE_699: usize = 5;
-const IN_699: usize = 5;
-const OUT_699: usize = 2;
-fn aiur_fn_699(
-  inp: [G; IN_699],
+const INPUT_SIZE_704: usize = 5;
+const IN_704: usize = 5;
+const OUT_704: usize = 2;
+fn aiur_fn_704(
+  inp: [G; IN_704],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_699], ExecError> {
+) -> Result<[G; OUT_704], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58765,8 +58953,8 @@ fn aiur_fn_699(
       1u64 => {
         let __v_11: G = G::from_u64(0);
         let __v_12: G = G::from_u64(0);
-        let __ret: [G; OUT_699] = [__v_11, __v_12];
-        record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_704] = [__v_11, __v_12];
+        record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -58778,7 +58966,7 @@ fn aiur_fn_699(
     break '__mc_0 [__v_12];
   },
   _ => {
-    let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_8, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } };
     let __v_12: G = __r_arr[0];
     break '__mc_0 [__v_12];
   },
@@ -58789,18 +58977,18 @@ fn aiur_fn_699(
         match __v_13.as_canonical_u64() {
           1u64 => {
             let __v_14: G = G::from_u64(1);
-            let __ret: [G; OUT_699] = [__v_14, __v_4];
-            record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_704] = [__v_14, __v_4];
+            record.function_queries[704].finish(&inp[..], &__ret[..], !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_699] = { let __args: [G; IN_699] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[699].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[699].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[699].bump_multiplicity(__i); } let __ret: [G; OUT_699] = unsafe { *(record.function_queries[699].output_at(__i).as_ptr() as *const [G; OUT_699]) }; __ret }, _ => aiur_fn_699(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_10, __v_1, __v_2, __v_3, __v_15]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } };
             let __v_16: G = __r_arr[0];
             let __v_17: G = __r_arr[1];
-            let __ret: [G; OUT_699] = [__v_16, __v_17];
-            record.function_queries[699].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_704] = [__v_16, __v_17];
+            record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -58812,15 +59000,15 @@ fn aiur_fn_699(
   })
 }
 
-const INPUT_SIZE_700: usize = 3;
-const IN_700: usize = 3;
-const OUT_700: usize = 1;
-fn aiur_fn_700(
-  inp: [G; IN_700],
+const INPUT_SIZE_705: usize = 3;
+const IN_705: usize = 3;
+const OUT_705: usize = 1;
+fn aiur_fn_705(
+  inp: [G; IN_705],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_700], ExecError> {
+) -> Result<[G; OUT_705], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58832,8 +59020,8 @@ fn aiur_fn_700(
     match __v_3.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(1);
-        let __ret: [G; OUT_700] = [__v_6];
-        record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_705] = [__v_6];
+        record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -58844,28 +59032,28 @@ fn aiur_fn_700(
         match __v_6.as_canonical_u64() {
           1u64 => {
             let __v_9: G = G::from_u64(0);
-            let __ret: [G; OUT_700] = [__v_9];
-            record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_705] = [__v_9];
+            record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
             let __v_9: G = G::from_u64(0);
-            let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_4, __v_2, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__args, record, io_buffer, __cu)? } };
             let __v_10: G = __r_arr[0];
-            let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[642].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[642].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[642].bump_multiplicity(__i); } let __ret: [G; OUT_642] = unsafe { *(record.function_queries[642].output_at(__i).as_ptr() as *const [G; OUT_642]) }; __ret }, _ => aiur_fn_642(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_10, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[647].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[647].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[647].bump_multiplicity(__i); } let __ret: [G; OUT_647] = unsafe { *(record.function_queries[647].output_at(__i).as_ptr() as *const [G; OUT_647]) }; __ret }, _ => aiur_fn_647(__args, record, io_buffer, __cu)? } };
             let __v_11: G = __r_arr[0];
             match __v_11.as_canonical_u64() {
               1u64 => {
-                let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[700].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[700].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[700].bump_multiplicity(__i); } let __ret: [G; OUT_700] = unsafe { *(record.function_queries[700].output_at(__i).as_ptr() as *const [G; OUT_700]) }; __ret }, _ => aiur_fn_700(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_705] = { let __args: [G; IN_705] = [__v_5, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } };
                 let __v_12: G = __r_arr[0];
-                let __ret: [G; OUT_700] = [__v_12];
-                record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_705] = [__v_12];
+                record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
                 let __v_12: G = G::from_u64(0);
-                let __ret: [G; OUT_700] = [__v_12];
-                record.function_queries[700].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_705] = [__v_12];
+                record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -58882,15 +59070,15 @@ fn aiur_fn_700(
   })
 }
 
-const INPUT_SIZE_701: usize = 7;
-const IN_701: usize = 7;
-const OUT_701: usize = 4;
-fn aiur_fn_701(
-  inp: [G; IN_701],
+const INPUT_SIZE_706: usize = 7;
+const IN_706: usize = 7;
+const OUT_706: usize = 4;
+fn aiur_fn_706(
+  inp: [G; IN_706],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_701], ExecError> {
+) -> Result<[G; OUT_706], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58907,7 +59095,7 @@ fn aiur_fn_701(
     match __v_7.as_canonical_u64() {
       5u64 => {
         let __v_11: G = (__v_6 + __v_5);
-        let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[697].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[697].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[697].bump_multiplicity(__i); } let __ret: [G; OUT_697] = unsafe { *(record.function_queries[697].output_at(__i).as_ptr() as *const [G; OUT_697]) }; __ret }, _ => aiur_fn_697(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_8, __v_1, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__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);
@@ -58920,53 +59108,53 @@ fn aiur_fn_701(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_701] = { let __args: [G; IN_701] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_9, __v_1, __v_15, __v_17, __v_19, __v_21, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__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_701] = [__v_22, __v_23, __v_24, __v_25];
-            record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_706] = [__v_22, __v_23, __v_24, __v_25];
+            record.function_queries[706].finish(&inp[..], &__ret[..], !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_701] = { let __args: [G; IN_701] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[701].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[701].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[701].bump_multiplicity(__i); } let __ret: [G; OUT_701] = unsafe { *(record.function_queries[701].output_at(__i).as_ptr() as *const [G; OUT_701]) }; __ret }, _ => aiur_fn_701(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_9, __v_1, __v_15, __v_3, __v_4, __v_17, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__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_701] = [__v_18, __v_19, __v_20, __v_21];
-            record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_706] = [__v_18, __v_19, __v_20, __v_21];
+            record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
       },
       _ => {
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_12: G = __r_arr[0];
-        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __ret: [G; OUT_701] = [__v_11, __v_12, __v_13, __v_0];
-        record.function_queries[701].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_706] = [__v_11, __v_12, __v_13, __v_0];
+        record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_702: usize = 4;
-const IN_702: usize = 4;
-const OUT_702: usize = 1;
-fn aiur_fn_702(
-  inp: [G; IN_702],
+const INPUT_SIZE_707: usize = 4;
+const IN_707: usize = 4;
+const OUT_707: usize = 1;
+fn aiur_fn_707(
+  inp: [G; IN_707],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_702], ExecError> {
+) -> Result<[G; OUT_707], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -58984,12 +59172,12 @@ fn aiur_fn_702(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_702] = [__v_12];
-        record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_707] = [__v_12];
+        record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_11: G = __loaded[0];
@@ -59006,26 +59194,26 @@ fn aiur_fn_702(
         let __v_22: G = __loaded[11];
         match __v_11.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[666].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[666].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[666].bump_multiplicity(__i); } let __ret: [G; OUT_666] = unsafe { *(record.function_queries[666].output_at(__i).as_ptr() as *const [G; OUT_666]) }; __ret }, _ => aiur_fn_666(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__v_5, __v_13, __v_14, __v_15, __v_8, __v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[671].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[671].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[671].bump_multiplicity(__i); } let __ret: [G; OUT_671] = unsafe { *(record.function_queries[671].output_at(__i).as_ptr() as *const [G; OUT_671]) }; __ret }, _ => aiur_fn_671(__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_358] = { let __args: [G; IN_358] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[358].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[358].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[358].bump_multiplicity(__i); } let __ret: [G; OUT_358] = unsafe { *(record.function_queries[358].output_at(__i).as_ptr() as *const [G; OUT_358]) }; __ret }, _ => aiur_fn_358(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_23, __v_3, __v_24]; let __cu = unconstrained; let __hit = record.function_queries[363].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[363].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[363].bump_multiplicity(__i); } let __ret: [G; OUT_363] = unsafe { *(record.function_queries[363].output_at(__i).as_ptr() as *const [G; OUT_363]) }; __ret }, _ => aiur_fn_363(__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_702] = { let __args: [G; IN_702] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_9, __v_1, __v_2, __v_28]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_702] = [__v_30];
-            record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_707] = [__v_30];
+            record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[702].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[702].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[702].bump_multiplicity(__i); } let __ret: [G; OUT_702] = unsafe { *(record.function_queries[702].output_at(__i).as_ptr() as *const [G; OUT_702]) }; __ret }, _ => aiur_fn_702(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } };
             let __v_23: G = __r_arr[0];
-            let __ret: [G; OUT_702] = [__v_23];
-            record.function_queries[702].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_707] = [__v_23];
+            record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -59037,15 +59225,15 @@ fn aiur_fn_702(
   })
 }
 
-const INPUT_SIZE_703: usize = 13;
-const IN_703: usize = 13;
-const OUT_703: usize = 0;
-fn aiur_fn_703(
-  inp: [G; IN_703],
+const INPUT_SIZE_708: usize = 13;
+const IN_708: usize = 13;
+const OUT_708: usize = 0;
+fn aiur_fn_708(
+  inp: [G; IN_708],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_703], ExecError> {
+) -> Result<[G; OUT_708], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59062,9 +59250,9 @@ fn aiur_fn_703(
     let __v_12: G = inp[12];
     match __v_0.as_canonical_u64() {
       7u64 => {
-        let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[634].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[634].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[634].bump_multiplicity(__i); } let __ret: [G; OUT_634] = unsafe { *(record.function_queries[634].output_at(__i).as_ptr() as *const [G; OUT_634]) }; __ret }, _ => aiur_fn_634(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_2, __v_3, __v_5, __v_6, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[639].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[639].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[639].bump_multiplicity(__i); } let __ret: [G; OUT_639] = unsafe { *(record.function_queries[639].output_at(__i).as_ptr() as *const [G; OUT_639]) }; __ret }, _ => aiur_fn_639(__args, record, io_buffer, __cu)? } };
         let __v_13: G = __r_arr[0];
-        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_15: G = __loaded[0];
@@ -59081,9 +59269,9 @@ fn aiur_fn_703(
         let __v_26: G = __loaded[11];
         match __v_15.as_canonical_u64() {
           5u64 => {
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
             let __v_27: G = __r_arr[0];
-            let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[632].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[632].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[632].bump_multiplicity(__i); } let __ret: [G; OUT_632] = unsafe { *(record.function_queries[632].output_at(__i).as_ptr() as *const [G; OUT_632]) }; __ret }, _ => aiur_fn_632(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[637].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[637].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[637].bump_multiplicity(__i); } let __ret: [G; OUT_637] = unsafe { *(record.function_queries[637].output_at(__i).as_ptr() as *const [G; OUT_637]) }; __ret }, _ => aiur_fn_637(__args, record, io_buffer, __cu)? } };
             let __v_28: G = __r_arr[0];
             let __v_29: G = G::from_u64(1);
             let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_10, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[2].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[2].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[2].bump_multiplicity(__i); } let __ret: [G; OUT_2] = unsafe { *(record.function_queries[2].output_at(__i).as_ptr() as *const [G; OUT_2]) }; __ret }, _ => aiur_fn_2(__args, record, io_buffer, __cu)? } };
@@ -59091,7 +59279,7 @@ fn aiur_fn_703(
             let __v_31: G = (__v_29 - __v_30);
             let __v_32: G = (__v_28 * __v_31);
             let __v_33: G = (__v_27 * __v_32);
-            let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[787].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[787].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { *(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787]) }; __ret }, _ => aiur_fn_787(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[792].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[792].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { *(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792]) }; __ret }, _ => aiur_fn_792(__args, record, io_buffer, __cu)? } };
             let __v_34: G = __r_arr[0];
             if (__v_34 != __v_20) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_20.as_canonical_u64(), msg: Some("recursor rule count differs from the inductive's ctor count".to_string()) });
@@ -59101,11 +59289,11 @@ fn aiur_fn_703(
             let __v_37: G = (__v_35 + __v_36);
             let __v_38: G = G::from_u64(1);
             let __v_39: G = (__v_37 + __v_38);
-            let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_2, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_2, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__args, record, io_buffer, __cu)? } };
             let __v_40: G = __r_arr[0];
             let __v_41: G = (__v_5 + __v_6);
             let __v_42: G = (__v_3 + __v_41);
-            let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_7, __v_42, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_7, __v_42, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i); } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } };
             let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_33.as_canonical_u64() {
   1u64 => {
     break '__mc_0 [];
@@ -59118,20 +59306,20 @@ fn aiur_fn_703(
       return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("recursor index count differs from its inductive's".to_string()) });
     }
     let __v_43: G = (__v_18 + __v_19);
-    let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[704].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[704].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[704].bump_multiplicity(__i); } let __ret: [G; OUT_704] = unsafe { *(record.function_queries[704].output_at(__i).as_ptr() as *const [G; OUT_704]) }; __ret }, _ => aiur_fn_704(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_2, __v_3, __v_5, __v_6, __v_4, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
     break '__mc_0 [];
   },
 }
  };
-            let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_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; let __hit = record.function_queries[630].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[630].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[630].bump_multiplicity(__i); } let __ret: [G; OUT_630] = unsafe { *(record.function_queries[630].output_at(__i).as_ptr() as *const [G; OUT_630]) }; __ret }, _ => aiur_fn_630(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_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; let __hit = record.function_queries[635].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[635].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[635].bump_multiplicity(__i); } let __ret: [G; OUT_635] = unsafe { *(record.function_queries[635].output_at(__i).as_ptr() as *const [G; OUT_635]) }; __ret }, _ => aiur_fn_635(__args, record, io_buffer, __cu)? } };
             let __v_43: G = __r_arr[0];
             if (__v_8 != __v_43) {
               return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_43.as_canonical_u64(), msg: Some("recursor k_flag disagrees with its inductive's K eligibility".to_string()) });
             }
-            let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__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; let __hit = record.function_queries[622].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[622].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[622].bump_multiplicity(__i); } let __ret: [G; OUT_622] = unsafe { *(record.function_queries[622].output_at(__i).as_ptr() as *const [G; OUT_622]) }; __ret }, _ => aiur_fn_622(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_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; let __hit = record.function_queries[672].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[672].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[672].bump_multiplicity(__i); } let __ret: [G; OUT_672] = unsafe { *(record.function_queries[672].output_at(__i).as_ptr() as *const [G; OUT_672]) }; __ret }, _ => aiur_fn_672(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_703] = [];
-            record.function_queries[703].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__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; let __hit = record.function_queries[627].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[627].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[627].bump_multiplicity(__i); } let __ret: [G; OUT_627] = unsafe { *(record.function_queries[627].output_at(__i).as_ptr() as *const [G; OUT_627]) }; __ret }, _ => aiur_fn_627(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[677].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[677].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[677].bump_multiplicity(__i); } let __ret: [G; OUT_677] = unsafe { *(record.function_queries[677].output_at(__i).as_ptr() as *const [G; OUT_677]) }; __ret }, _ => aiur_fn_677(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_708] = [];
+            record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -59146,15 +59334,15 @@ fn aiur_fn_703(
   })
 }
 
-const INPUT_SIZE_704: usize = 6;
-const IN_704: usize = 6;
-const OUT_704: usize = 0;
-fn aiur_fn_704(
-  inp: [G; IN_704],
+const INPUT_SIZE_709: usize = 6;
+const IN_709: usize = 6;
+const OUT_709: usize = 0;
+fn aiur_fn_709(
+  inp: [G; IN_709],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_704], ExecError> {
+) -> Result<[G; OUT_709], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59165,7 +59353,7 @@ fn aiur_fn_704(
     let __v_6: G = (__v_3 + __v_4);
     let __v_7: G = (__v_2 + __v_6);
     let __v_8: G = (__v_1 + __v_7);
-    let __r_arr: [G; OUT_597] = { let __args: [G; IN_597] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[597].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[597].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[597].bump_multiplicity(__i); } let __ret: [G; OUT_597] = unsafe { *(record.function_queries[597].output_at(__i).as_ptr() as *const [G; OUT_597]) }; __ret }, _ => aiur_fn_597(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[602].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[602].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[602].bump_multiplicity(__i); } let __ret: [G; OUT_602] = unsafe { *(record.function_queries[602].output_at(__i).as_ptr() as *const [G; OUT_602]) }; __ret }, _ => aiur_fn_602(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr };
     let __v_10: G = __loaded[0];
@@ -59174,16 +59362,16 @@ fn aiur_fn_704(
     let __v_13: G = __loaded[3];
     match __v_10.as_canonical_u64() {
       5u64 => {
-        let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[115].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[115].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[115].bump_multiplicity(__i); } let __ret: [G; OUT_115] = unsafe { *(record.function_queries[115].output_at(__i).as_ptr() as *const [G; OUT_115]) }; __ret }, _ => aiur_fn_115(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[120].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[120].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[120].bump_multiplicity(__i); } let __ret: [G; OUT_120] = unsafe { *(record.function_queries[120].output_at(__i).as_ptr() as *const [G; OUT_120]) }; __ret }, _ => aiur_fn_120(__args, record, io_buffer, __cu)? } };
         let __v_14: G = __r_arr[0];
         let __v_15: G = __r_arr[1];
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_15]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
         let __v_16: G = __r_arr[0];
         if (__v_16 != __v_5) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_5.as_canonical_u64(), msg: Some("recursor major premise has the wrong number of spine args".to_string()) });
         }
-        let __ret: [G; OUT_704] = [];
-        record.function_queries[704].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_709] = [];
+        record.function_queries[709].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -59193,15 +59381,15 @@ fn aiur_fn_704(
   })
 }
 
-const INPUT_SIZE_705: usize = 2;
-const IN_705: usize = 2;
-const OUT_705: usize = 1;
-fn aiur_fn_705(
-  inp: [G; IN_705],
+const INPUT_SIZE_710: usize = 2;
+const IN_710: usize = 2;
+const OUT_710: usize = 1;
+fn aiur_fn_710(
+  inp: [G; IN_710],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_705], ExecError> {
+) -> Result<[G; OUT_710], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59211,8 +59399,8 @@ fn aiur_fn_705(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_705] = [__v_5];
-        record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_710] = [__v_5];
+        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -59222,26 +59410,26 @@ fn aiur_fn_705(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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_705] = { let __args: [G; IN_705] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[705].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[705].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[705].bump_multiplicity(__i); } let __ret: [G; OUT_705] = unsafe { *(record.function_queries[705].output_at(__i).as_ptr() as *const [G; OUT_705]) }; __ret }, _ => aiur_fn_705(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_0, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_705] = [__v_10];
-        record.function_queries[705].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_710] = [__v_10];
+        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_706: usize = 3;
-const IN_706: usize = 3;
-const OUT_706: usize = 0;
-fn aiur_fn_706(
-  inp: [G; IN_706],
+const INPUT_SIZE_711: usize = 3;
+const IN_711: usize = 3;
+const OUT_711: usize = 0;
+fn aiur_fn_711(
+  inp: [G; IN_711],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_706], ExecError> {
+) -> Result<[G; OUT_711], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59254,18 +59442,18 @@ fn aiur_fn_706(
     let __v_7: G = __loaded[4];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_706] = [];
-        record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_711] = [];
+        record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_4.as_canonical_u64() {
           _ => {
             let __v_8: G = (__v_1 + __v_5);
-            let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_706] = { let __args: [G; IN_706] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[706].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[706].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[706].bump_multiplicity(__i); } let __ret: [G; OUT_706] = unsafe { *(record.function_queries[706].output_at(__i).as_ptr() as *const [G; OUT_706]) }; __ret }, _ => aiur_fn_706(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_706] = [];
-            record.function_queries[706].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_6, __v_8, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i); } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_711] = [];
+            record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -59277,15 +59465,15 @@ fn aiur_fn_706(
   })
 }
 
-const INPUT_SIZE_707: usize = 4;
-const IN_707: usize = 4;
-const OUT_707: usize = 3;
-fn aiur_fn_707(
-  inp: [G; IN_707],
+const INPUT_SIZE_712: usize = 4;
+const IN_712: usize = 4;
+const OUT_712: usize = 3;
+fn aiur_fn_712(
+  inp: [G; IN_712],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_707], ExecError> {
+) -> Result<[G; OUT_712], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59293,8 +59481,8 @@ fn aiur_fn_707(
     let __v_3: G = inp[3];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_707] = [__v_0, __v_2, __v_3];
-        record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_712] = [__v_0, __v_2, __v_3];
+        record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -59311,17 +59499,17 @@ fn aiur_fn_707(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[707].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[707].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[707].bump_multiplicity(__i); } let __ret: [G; OUT_707] = unsafe { *(record.function_queries[707].output_at(__i).as_ptr() as *const [G; OUT_707]) }; __ret }, _ => aiur_fn_707(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_6, __v_9, __v_11, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__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_707] = [__v_14, __v_15, __v_16];
-            record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_712] = [__v_14, __v_15, __v_16];
+            record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_707] = [__v_0, __v_2, __v_3];
-            record.function_queries[707].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_712] = [__v_0, __v_2, __v_3];
+            record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -59330,15 +59518,15 @@ fn aiur_fn_707(
   })
 }
 
-const INPUT_SIZE_708: usize = 13;
-const IN_708: usize = 13;
-const OUT_708: usize = 0;
-fn aiur_fn_708(
-  inp: [G; IN_708],
+const INPUT_SIZE_713: usize = 13;
+const IN_713: usize = 13;
+const OUT_713: usize = 0;
+fn aiur_fn_713(
+  inp: [G; IN_713],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_708], ExecError> {
+) -> Result<[G; OUT_713], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -59353,131 +59541,131 @@ fn aiur_fn_708(
     let __v_10: G = inp[10];
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
-    let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[586].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[586].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[586].bump_multiplicity(__i); } let __ret: [G; OUT_586] = unsafe { *(record.function_queries[586].output_at(__i).as_ptr() as *const [G; OUT_586]) }; __ret }, _ => aiur_fn_586(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
     let __v_13: G = __r_arr[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __v_20: G = G::from_u64(0);
         let __v_21: G = G::from_u64(0);
         let __v_22: G = { 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[324].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[324].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[324].bump_multiplicity(__i); } let __ret: [G; OUT_324] = unsafe { *(record.function_queries[324].output_at(__i).as_ptr() as *const [G; OUT_324]) }; __ret }, _ => aiur_fn_324(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[329].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[329].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[329].bump_multiplicity(__i); } let __ret: [G; OUT_329] = unsafe { *(record.function_queries[329].output_at(__i).as_ptr() as *const [G; OUT_329]) }; __ret }, _ => aiur_fn_329(__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 __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
         let __v_25: G = G::from_u64(1);
         let __v_26: G = G::from_u64(1);
         let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_2, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
         let __v_15: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_3, __v_15, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[510].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[510].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[510].bump_multiplicity(__i); } let __ret: [G; OUT_510] = unsafe { *(record.function_queries[510].output_at(__i).as_ptr() as *const [G; OUT_510]) }; __ret }, _ => aiur_fn_510(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_3, __v_2, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[515].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[515].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[515].bump_multiplicity(__i); } let __ret: [G; OUT_515] = unsafe { *(record.function_queries[515].output_at(__i).as_ptr() as *const [G; OUT_515]) }; __ret }, _ => aiur_fn_515(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_12, __v_3, __v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[585].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => aiur_fn_585(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_620] = { let __args: [G; IN_620] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[620].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[620].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[620].bump_multiplicity(__i); } let __ret: [G; OUT_620] = unsafe { *(record.function_queries[620].output_at(__i).as_ptr() as *const [G; OUT_620]) }; __ret }, _ => aiur_fn_620(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __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; let __hit = record.function_queries[623].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[623].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[623].bump_multiplicity(__i); } let __ret: [G; OUT_623] = unsafe { *(record.function_queries[623].output_at(__i).as_ptr() as *const [G; OUT_623]) }; __ret }, _ => aiur_fn_623(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_2, __v_3, __v_4, __v_5, __v_1, __v_7, __v_8, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[625].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[625].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[625].bump_multiplicity(__i); } let __ret: [G; OUT_625] = unsafe { *(record.function_queries[625].output_at(__i).as_ptr() as *const [G; OUT_625]) }; __ret }, _ => aiur_fn_625(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_0, __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; let __hit = record.function_queries[628].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[628].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[628].bump_multiplicity(__i); } let __ret: [G; OUT_628] = unsafe { *(record.function_queries[628].output_at(__i).as_ptr() as *const [G; OUT_628]) }; __ret }, _ => aiur_fn_628(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[289].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[289].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[289].bump_multiplicity(__i); } let __ret: [G; OUT_289] = unsafe { *(record.function_queries[289].output_at(__i).as_ptr() as *const [G; OUT_289]) }; __ret }, _ => aiur_fn_289(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
         let __v_20: G = __loaded[0];
@@ -59497,28 +59685,28 @@ fn aiur_fn_708(
             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_603] = { let __args: [G; IN_603] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[603].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[603].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[603].bump_multiplicity(__i); } let __ret: [G; OUT_603] = unsafe { *(record.function_queries[603].output_at(__i).as_ptr() as *const [G; OUT_603]) }; __ret }, _ => aiur_fn_603(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[601].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[601].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[601].bump_multiplicity(__i); } let __ret: [G; OUT_601] = unsafe { *(record.function_queries[601].output_at(__i).as_ptr() as *const [G; OUT_601]) }; __ret }, _ => aiur_fn_601(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_22, __v_2, __v_23]; let __cu = unconstrained; let __hit = record.function_queries[608].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[608].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[608].bump_multiplicity(__i); } let __ret: [G; OUT_608] = unsafe { *(record.function_queries[608].output_at(__i).as_ptr() as *const [G; OUT_608]) }; __ret }, _ => aiur_fn_608(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6, __v_24, __v_7, __v_21, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[606].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[606].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[606].bump_multiplicity(__i); } let __ret: [G; OUT_606] = unsafe { *(record.function_queries[606].output_at(__i).as_ptr() as *const [G; OUT_606]) }; __ret }, _ => aiur_fn_606(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[604].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[604].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[604].bump_multiplicity(__i); } let __ret: [G; OUT_604] = unsafe { *(record.function_queries[604].output_at(__i).as_ptr() as *const [G; OUT_604]) }; __ret }, _ => aiur_fn_604(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__v_22, __v_32, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[609].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[609].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[609].bump_multiplicity(__i); } let __ret: [G; OUT_609] = unsafe { *(record.function_queries[609].output_at(__i).as_ptr() as *const [G; OUT_609]) }; __ret }, _ => aiur_fn_609(__args, record, io_buffer, __cu)? } };
             let __v_36: G = __r_arr[0];
-            let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[607].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[607].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[607].bump_multiplicity(__i); } let __ret: [G; OUT_607] = unsafe { *(record.function_queries[607].output_at(__i).as_ptr() as *const [G; OUT_607]) }; __ret }, _ => aiur_fn_607(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_6, __v_36]; let __cu = unconstrained; let __hit = record.function_queries[612].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[612].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[612].bump_multiplicity(__i); } let __ret: [G; OUT_612] = unsafe { *(record.function_queries[612].output_at(__i).as_ptr() as *const [G; OUT_612]) }; __ret }, _ => aiur_fn_612(__args, record, io_buffer, __cu)? } };
             match __v_26.as_canonical_u64() {
               0u64 => {
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[619].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[619].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[619].bump_multiplicity(__i); } let __ret: [G; OUT_619] = unsafe { *(record.function_queries[619].output_at(__i).as_ptr() as *const [G; OUT_619]) }; __ret }, _ => aiur_fn_619(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_708] = [];
-                record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_2, __v_6, __v_3, __v_39]; let __cu = unconstrained; let __hit = record.function_queries[624].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[624].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[624].bump_multiplicity(__i); } let __ret: [G; OUT_624] = unsafe { *(record.function_queries[624].output_at(__i).as_ptr() as *const [G; OUT_624]) }; __ret }, _ => aiur_fn_624(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_713] = [];
+                record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __ret: [G; OUT_708] = [];
-                record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_713] = [];
+                record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -59530,17 +59718,17 @@ fn aiur_fn_708(
       },
       7u64 => {
         let __v_14: G = G::from_u64(0);
-        let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[591].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[591].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[591].bump_multiplicity(__i); } let __ret: [G; OUT_591] = unsafe { *(record.function_queries[591].output_at(__i).as_ptr() as *const [G; OUT_591]) }; __ret }, _ => aiur_fn_591(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = [__v_2, __v_14, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[596].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[596].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[596].bump_multiplicity(__i); } let __ret: [G; OUT_596] = unsafe { *(record.function_queries[596].output_at(__i).as_ptr() as *const [G; OUT_596]) }; __ret }, _ => aiur_fn_596(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[509].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[509].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[509].bump_multiplicity(__i); } let __ret: [G; OUT_509] = unsafe { *(record.function_queries[509].output_at(__i).as_ptr() as *const [G; OUT_509]) }; __ret }, _ => aiur_fn_509(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_2, __v_17]; let __cu = unconstrained; let __hit = record.function_queries[514].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[514].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[514].bump_multiplicity(__i); } let __ret: [G; OUT_514] = unsafe { *(record.function_queries[514].output_at(__i).as_ptr() as *const [G; OUT_514]) }; __ret }, _ => aiur_fn_514(__args, record, io_buffer, __cu)? } };
         let __v_18: G = __r_arr[0];
-        let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[588].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[588].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[588].bump_multiplicity(__i); } let __ret: [G; OUT_588] = unsafe { *(record.function_queries[588].output_at(__i).as_ptr() as *const [G; OUT_588]) }; __ret }, _ => aiur_fn_588(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[585].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[585].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[585].bump_multiplicity(__i); } let __ret: [G; OUT_585] = unsafe { *(record.function_queries[585].output_at(__i).as_ptr() as *const [G; OUT_585]) }; __ret }, _ => aiur_fn_585(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_0, __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; let __hit = record.function_queries[703].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[703].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[703].bump_multiplicity(__i); } let __ret: [G; OUT_703] = unsafe { *(record.function_queries[703].output_at(__i).as_ptr() as *const [G; OUT_703]) }; __ret }, _ => aiur_fn_703(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_708] = [];
-        record.function_queries[708].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_13, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[593].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[593].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[593].bump_multiplicity(__i); } let __ret: [G; OUT_593] = unsafe { *(record.function_queries[593].output_at(__i).as_ptr() as *const [G; OUT_593]) }; __ret }, _ => aiur_fn_593(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[590].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[590].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[590].bump_multiplicity(__i); } let __ret: [G; OUT_590] = unsafe { *(record.function_queries[590].output_at(__i).as_ptr() as *const [G; OUT_590]) }; __ret }, _ => aiur_fn_590(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_713] = [];
+        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -59550,18 +59738,18 @@ fn aiur_fn_708(
   })
 }
 
-const INPUT_SIZE_709: usize = 1;
-const IN_709: usize = 1;
-const OUT_709: usize = 0;
-fn aiur_fn_709(
-  inp: [G; IN_709],
+const INPUT_SIZE_714: usize = 1;
+const IN_714: usize = 1;
+const OUT_714: usize = 0;
+fn aiur_fn_714(
+  inp: [G; IN_714],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_709], ExecError> {
+) -> Result<[G; OUT_714], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_2: G = __loaded[0];
@@ -59576,22 +59764,22 @@ fn aiur_fn_709(
     let __v_11: G = __loaded[9];
     let __v_12: G = __loaded[10];
     let __v_13: G = __loaded[11];
-    let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_709] = [];
-    record.function_queries[709].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_714] = [];
+    record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_710: usize = 1;
-const IN_710: usize = 1;
-const OUT_710: usize = 1;
-fn aiur_fn_710(
-  inp: [G; IN_710],
+const INPUT_SIZE_715: usize = 1;
+const IN_715: usize = 1;
+const OUT_715: usize = 1;
+fn aiur_fn_715(
+  inp: [G; IN_715],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_710], ExecError> {
+) -> Result<[G; OUT_715], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
@@ -59622,90 +59810,90 @@ fn aiur_fn_710(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_710] = [__v_24];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_24];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
         let __v_19: G = G::from_u64(0);
         let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[17].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[17].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[17].bump_multiplicity(__i); } let __ret: [G; OUT_17] = unsafe { *(record.function_queries[17].output_at(__i).as_ptr() as *const [G; OUT_17]) }; __ret }, _ => aiur_fn_17(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_710] = [__v_22];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_22];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __ret: [G; OUT_710] = [__v_21];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_21];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __ret: [G; OUT_710] = [__v_21];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_21];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       9u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_19, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __ret: [G; OUT_710] = [__v_21];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_21];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       10u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_20: G = __r_arr[0];
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_21: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_22: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_19, __v_22]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_23: G = __r_arr[0];
-        let __ret: [G; OUT_710] = [__v_23];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_23];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_710] = [__v_21];
-        record.function_queries[710].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_715] = [__v_21];
+        record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_711: usize = 1;
-const IN_711: usize = 1;
-const OUT_711: usize = 1;
-fn aiur_fn_711(
-  inp: [G; IN_711],
+const INPUT_SIZE_716: usize = 1;
+const IN_716: usize = 1;
+const OUT_716: usize = 1;
+fn aiur_fn_716(
+  inp: [G; IN_716],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_711], ExecError> {
+) -> Result<[G; OUT_716], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -59717,19 +59905,19 @@ fn aiur_fn_711(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_711] = [__v_6];
-        record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_716] = [__v_6];
+        record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
-        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i); } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
-        let __ret: [G; OUT_711] = [__v_6];
-        record.function_queries[711].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_716] = [__v_6];
+        record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -59739,15 +59927,15 @@ fn aiur_fn_711(
   })
 }
 
-const INPUT_SIZE_712: usize = 1;
-const IN_712: usize = 1;
-const OUT_712: usize = 1;
-fn aiur_fn_712(
-  inp: [G; IN_712],
+const INPUT_SIZE_717: usize = 1;
+const IN_717: usize = 1;
+const OUT_717: usize = 1;
+fn aiur_fn_717(
+  inp: [G; IN_717],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_712], ExecError> {
+) -> Result<[G; OUT_717], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
@@ -59767,21 +59955,21 @@ fn aiur_fn_712(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_712] = [__v_14];
-        record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_717] = [__v_14];
+        record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_2.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
             let __v_12: G = __r_arr[0];
-            let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
             let __v_13: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
             let __v_14: G = __r_arr[0];
-            let __ret: [G; OUT_712] = [__v_14];
-            record.function_queries[712].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_717] = [__v_14];
+            record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -59793,15 +59981,15 @@ fn aiur_fn_712(
   })
 }
 
-const INPUT_SIZE_713: usize = 1;
-const IN_713: usize = 1;
-const OUT_713: usize = 1;
-fn aiur_fn_713(
-  inp: [G; IN_713],
+const INPUT_SIZE_718: usize = 1;
+const IN_718: usize = 1;
+const OUT_718: usize = 1;
+fn aiur_fn_718(
+  inp: [G; IN_718],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_713], ExecError> {
+) -> Result<[G; OUT_718], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
@@ -59846,21 +60034,21 @@ fn aiur_fn_713(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_713] = [__v_39];
-        record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_718] = [__v_39];
+        record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         match __v_2.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_35]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
             let __v_37: G = __r_arr[0];
-            let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } };
             let __v_38: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_37, __v_38]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
             let __v_39: G = __r_arr[0];
-            let __ret: [G; OUT_713] = [__v_39];
-            record.function_queries[713].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_718] = [__v_39];
+            record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -59872,15 +60060,15 @@ fn aiur_fn_713(
   })
 }
 
-const INPUT_SIZE_714: usize = 1;
-const IN_714: usize = 1;
-const OUT_714: usize = 1;
-fn aiur_fn_714(
-  inp: [G; IN_714],
+const INPUT_SIZE_719: usize = 1;
+const IN_719: usize = 1;
+const OUT_719: usize = 1;
+fn aiur_fn_719(
+  inp: [G; IN_719],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_714], ExecError> {
+) -> Result<[G; OUT_719], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
@@ -59936,8 +60124,8 @@ fn aiur_fn_714(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_714] = [__v_50];
-        record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_719] = [__v_50];
+        record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -59945,18 +60133,18 @@ fn aiur_fn_714(
           0u64 => {
             match __v_3.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_13]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_14]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
-                let __ret: [G; OUT_714] = [__v_52];
-                record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_719] = [__v_52];
+                record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -59964,18 +60152,18 @@ fn aiur_fn_714(
           1u64 => {
             match __v_3.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_28]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
-                let __ret: [G; OUT_714] = [__v_52];
-                record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_719] = [__v_52];
+                record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -59983,18 +60171,18 @@ fn aiur_fn_714(
           2u64 => {
             match __v_3.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_48: G = __r_arr[0];
-                let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_46]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_50, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
-                let __ret: [G; OUT_714] = [__v_52];
-                record.function_queries[714].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_719] = [__v_52];
+                record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -60011,15 +60199,15 @@ fn aiur_fn_714(
   })
 }
 
-const INPUT_SIZE_715: usize = 48;
-const IN_715: usize = 48;
-const OUT_715: usize = 1;
-fn aiur_fn_715(
-  inp: [G; IN_715],
+const INPUT_SIZE_720: usize = 48;
+const IN_720: usize = 48;
+const OUT_720: usize = 1;
+fn aiur_fn_720(
+  inp: [G; IN_720],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_715], ExecError> {
+) -> Result<[G; OUT_720], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60071,22 +60259,22 @@ fn aiur_fn_715(
     let __v_47: G = inp[47];
     match __v_0.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[711].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[711].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[711].bump_multiplicity(__i); } let __ret: [G; OUT_711] = unsafe { *(record.function_queries[711].output_at(__i).as_ptr() as *const [G; OUT_711]) }; __ret }, _ => aiur_fn_711(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_45]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } };
         let __v_48: G = __r_arr[0];
         match __v_0.as_canonical_u64() {
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
-                let __ret: [G; OUT_715] = [__v_52];
-                record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_720] = [__v_52];
+                record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -60094,16 +60282,16 @@ fn aiur_fn_715(
           1u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_43]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[712].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[712].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[712].bump_multiplicity(__i); } let __ret: [G; OUT_712] = unsafe { *(record.function_queries[712].output_at(__i).as_ptr() as *const [G; OUT_712]) }; __ret }, _ => aiur_fn_712(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_44]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_51: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_52: G = __r_arr[0];
-                let __ret: [G; OUT_715] = [__v_52];
-                record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_720] = [__v_52];
+                record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -60111,12 +60299,12 @@ fn aiur_fn_715(
           2u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __ret: [G; OUT_715] = [__v_50];
-                record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_720] = [__v_50];
+                record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -60124,28 +60312,28 @@ fn aiur_fn_715(
           3u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[710].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[710].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[710].bump_multiplicity(__i); } let __ret: [G; OUT_710] = unsafe { *(record.function_queries[710].output_at(__i).as_ptr() as *const [G; OUT_710]) }; __ret }, _ => aiur_fn_710(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
                 let __v_49: G = __r_arr[0];
-                let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
                 let __v_50: G = __r_arr[0];
-                let __ret: [G; OUT_715] = [__v_50];
-                record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_720] = [__v_50];
+                record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
           },
           8u64 => {
-            let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
             let __v_49: G = __r_arr[0];
-            let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
             let __v_50: G = __r_arr[0];
-            let __ret: [G; OUT_715] = [__v_50];
-            record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_720] = [__v_50];
+            record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __ret: [G; OUT_715] = [__v_48];
-            record.function_queries[715].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_720] = [__v_48];
+            record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -60154,15 +60342,15 @@ fn aiur_fn_715(
   })
 }
 
-const INPUT_SIZE_716: usize = 2;
-const IN_716: usize = 2;
-const OUT_716: usize = 1;
-fn aiur_fn_716(
-  inp: [G; IN_716],
+const INPUT_SIZE_721: usize = 2;
+const IN_721: usize = 2;
+const OUT_721: usize = 1;
+fn aiur_fn_721(
+  inp: [G; IN_721],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_716], ExecError> {
+) -> Result<[G; OUT_721], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60173,8 +60361,8 @@ fn aiur_fn_716(
     match __v_2.as_canonical_u64() {
       1u64 => {
         let __v_5: G = G::from_u64(0);
-        let __ret: [G; OUT_716] = [__v_5];
-        record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_721] = [__v_5];
+        record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -60182,15 +60370,15 @@ fn aiur_fn_716(
         match __v_5.as_canonical_u64() {
           0u64 => {
             let __v_6: G = G::from_u64(1);
-            let __ret: [G; OUT_716] = [__v_6];
-            record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_721] = [__v_6];
+            record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } };
             let __v_6: G = __r_arr[0];
-            let __ret: [G; OUT_716] = [__v_6];
-            record.function_queries[716].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_721] = [__v_6];
+            record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -60202,18 +60390,18 @@ fn aiur_fn_716(
   })
 }
 
-const INPUT_SIZE_717: usize = 1;
-const IN_717: usize = 1;
-const OUT_717: usize = 0;
-fn aiur_fn_717(
-  inp: [G; IN_717],
+const INPUT_SIZE_722: usize = 1;
+const IN_722: usize = 1;
+const OUT_722: usize = 0;
+fn aiur_fn_722(
+  inp: [G; IN_722],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_717], ExecError> {
+) -> Result<[G; OUT_722], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -60267,14 +60455,14 @@ fn aiur_fn_717(
         let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_1.as_canonical_u64() {
   8u64 => {
     let __v_49: G = G::from_u64(0);
-    let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0, __v_2, __v_2, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
     break '__mc_0 [];
   },
   7u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
         break '__mc_0 [];
       },
     }
@@ -60282,8 +60470,8 @@ fn aiur_fn_717(
   6u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
         break '__mc_0 [];
       },
     }
@@ -60291,8 +60479,8 @@ fn aiur_fn_717(
   4u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_18]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
         break '__mc_0 [];
       },
     }
@@ -60300,39 +60488,39 @@ fn aiur_fn_717(
   5u64 => {
     match __v_2.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
         break '__mc_0 [];
       },
     }
   },
   _ => {
-    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
     break '__mc_0 [];
   },
 }
  };
-        let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __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; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __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; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__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_718] = { let __args: [G; IN_718] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_717] = [];
-        record.function_queries[717].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_47, __v_49, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_722] = [];
+        record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_718: usize = 3;
-const IN_718: usize = 3;
-const OUT_718: usize = 0;
-fn aiur_fn_718(
-  inp: [G; IN_718],
+const INPUT_SIZE_723: usize = 3;
+const IN_723: usize = 3;
+const OUT_723: usize = 0;
+fn aiur_fn_723(
+  inp: [G; IN_723],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_718], ExecError> {
+) -> Result<[G; OUT_723], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60343,16 +60531,16 @@ fn aiur_fn_718(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_718] = [];
-        record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_723] = [];
+        record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_6.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_4]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -60362,9 +60550,9 @@ fn aiur_fn_718(
  };
         let __v_7: G = G::from_u64(1);
         let __v_8: G = (__v_2 + __v_7);
-        let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[718].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[718].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[718].bump_multiplicity(__i); } let __ret: [G; OUT_718] = unsafe { *(record.function_queries[718].output_at(__i).as_ptr() as *const [G; OUT_718]) }; __ret }, _ => aiur_fn_718(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_718] = [];
-        record.function_queries[718].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_723] = [];
+        record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -60374,15 +60562,15 @@ fn aiur_fn_718(
   })
 }
 
-const INPUT_SIZE_719: usize = 4;
-const IN_719: usize = 4;
-const OUT_719: usize = 0;
-fn aiur_fn_719(
-  inp: [G; IN_719],
+const INPUT_SIZE_724: usize = 4;
+const IN_724: usize = 4;
+const OUT_724: usize = 0;
+fn aiur_fn_724(
+  inp: [G; IN_724],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_719], ExecError> {
+) -> Result<[G; OUT_724], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60438,17 +60626,17 @@ fn aiur_fn_719(
     let __v_50: G = __loaded[46];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_719] = [];
-        record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_724] = [];
+        record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__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; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__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; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__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_719] = { let __args: [G; IN_719] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_719] = [];
-        record.function_queries[719].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0, __v_1, __v_50, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_724] = [];
+        record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -60458,15 +60646,15 @@ fn aiur_fn_719(
   })
 }
 
-const INPUT_SIZE_720: usize = 48;
-const IN_720: usize = 48;
-const OUT_720: usize = 0;
-fn aiur_fn_720(
-  inp: [G; IN_720],
+const INPUT_SIZE_725: usize = 48;
+const IN_725: usize = 48;
+const OUT_725: usize = 0;
+fn aiur_fn_725(
+  inp: [G; IN_725],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_720], ExecError> {
+) -> Result<[G; OUT_725], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60516,9 +60704,9 @@ fn aiur_fn_720(
     let __v_45: G = inp[45];
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
-    let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[294].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[294].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[294].bump_multiplicity(__i); } let __ret: [G; OUT_294] = unsafe { *(record.function_queries[294].output_at(__i).as_ptr() as *const [G; OUT_294]) }; __ret }, _ => aiur_fn_294(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = [__v_1, __v_0, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[299].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[299].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[299].bump_multiplicity(__i); } let __ret: [G; OUT_299] = unsafe { *(record.function_queries[299].output_at(__i).as_ptr() as *const [G; OUT_299]) }; __ret }, _ => aiur_fn_299(__args, record, io_buffer, __cu)? } };
     let __v_48: G = __r_arr[0];
-    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = [__v_48]; let __cu = unconstrained; let __hit = record.function_queries[292].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[292].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[292].bump_multiplicity(__i); } let __ret: [G; OUT_292] = unsafe { *(record.function_queries[292].output_at(__i).as_ptr() as *const [G; OUT_292]) }; __ret }, _ => aiur_fn_292(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 12 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 12] = __args[..12].try_into().unwrap(); __arr };
     let __v_50: G = __loaded[0];
@@ -60533,98 +60721,98 @@ fn aiur_fn_720(
     let __v_59: G = __loaded[9];
     let __v_60: G = __loaded[10];
     let __v_61: G = __loaded[11];
-    let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[708].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[708].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[708].bump_multiplicity(__i); } let __ret: [G; OUT_708] = unsafe { *(record.function_queries[708].output_at(__i).as_ptr() as *const [G; OUT_708]) }; __ret }, _ => aiur_fn_708(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_720] = [];
-    record.function_queries[720].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[713].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[713].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[713].bump_multiplicity(__i); } let __ret: [G; OUT_713] = unsafe { *(record.function_queries[713].output_at(__i).as_ptr() as *const [G; OUT_713]) }; __ret }, _ => aiur_fn_713(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_725] = [];
+    record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_721: usize = 1;
-const IN_721: usize = 1;
-const OUT_721: usize = 1;
-fn aiur_fn_721(
-  inp: [G; IN_721],
+const INPUT_SIZE_726: usize = 1;
+const IN_726: usize = 1;
+const OUT_726: usize = 1;
+fn aiur_fn_726(
+  inp: [G; IN_726],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_721], ExecError> {
+) -> Result<[G; OUT_726], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = G::from_u64(1);
     let __v_2: G = G::from_u64(1);
     let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_7]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_721] = [__v_8];
-    record.function_queries[721].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_726] = [__v_8];
+    record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_722: usize = 2;
-const IN_722: usize = 2;
-const OUT_722: usize = 1;
-fn aiur_fn_722(
-  inp: [G; IN_722],
+const INPUT_SIZE_727: usize = 2;
+const IN_727: usize = 2;
+const OUT_727: usize = 1;
+fn aiur_fn_727(
+  inp: [G; IN_727],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_722], ExecError> {
+) -> Result<[G; OUT_727], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = G::from_u64(1);
     let __v_3: G = G::from_u64(1);
     let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_1, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__args, record, io_buffer, __cu)? } };
     let __v_5: G = __r_arr[0];
-    let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[48].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[48].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[48].bump_multiplicity(__i); } let __ret: [G; OUT_48] = unsafe { *(record.function_queries[48].output_at(__i).as_ptr() as *const [G; OUT_48]) }; __ret }, _ => aiur_fn_48(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_0, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[50].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[50].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[50].bump_multiplicity(__i); } let __ret: [G; OUT_50] = unsafe { *(record.function_queries[50].output_at(__i).as_ptr() as *const [G; OUT_50]) }; __ret }, _ => aiur_fn_50(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_10: G = __r_arr[0];
-    let __ret: [G; OUT_722] = [__v_10];
-    record.function_queries[722].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_727] = [__v_10];
+    record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_723: usize = 1;
-const IN_723: usize = 1;
-const OUT_723: usize = 3;
-fn aiur_fn_723(
-  inp: [G; IN_723],
+const INPUT_SIZE_728: usize = 1;
+const IN_728: usize = 1;
+const OUT_728: usize = 3;
+fn aiur_fn_728(
+  inp: [G; IN_728],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_723], ExecError> {
+) -> Result<[G; OUT_728], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
-        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i); } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } };
         let __v_5: G = __r_arr[0];
         let __v_6: G = G::from_u64(0);
         let __v_7: G = G::from_u64(1);
         let __v_8: G = G::from_u64(1);
         let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_723] = [__v_5, __v_10, __v_4];
-        record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_728] = [__v_5, __v_10, __v_4];
+        record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
@@ -60664,25 +60852,25 @@ fn aiur_fn_723(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_723] = [__v_35, __v_38, __v_2];
-        record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_728] = [__v_35, __v_38, __v_2];
+        record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
         let __v_4: G = __r_arr[1];
         let __v_5: G = __r_arr[2];
-        let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = __r_arr[1];
         let __v_8: G = __r_arr[2];
-        let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_3, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
         let __v_9: G = __r_arr[0];
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
         let __v_10: G = __r_arr[0];
-        let __ret: [G; OUT_723] = [__v_9, __v_10, __v_8];
-        record.function_queries[723].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_728] = [__v_9, __v_10, __v_8];
+        record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -60692,15 +60880,15 @@ fn aiur_fn_723(
   })
 }
 
-const INPUT_SIZE_724: usize = 1;
-const IN_724: usize = 1;
-const OUT_724: usize = 1;
-fn aiur_fn_724(
-  inp: [G; IN_724],
+const INPUT_SIZE_729: usize = 1;
+const IN_729: usize = 1;
+const OUT_729: usize = 1;
+fn aiur_fn_729(
+  inp: [G; IN_729],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_724], ExecError> {
+) -> Result<[G; OUT_729], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
@@ -60743,7 +60931,7 @@ fn aiur_fn_724(
     let __v_36: G = G::from_u64(1);
     let __r_arr: [G; OUT_3] = { let __args: [G; IN_3] = [__v_36, __v_34, __v_35]; let __cu = true; let __hit = record.function_queries[3].get_index_of(&__args[..]); match __hit { Some(__i) if true => { let __ret: [G; OUT_3] = unsafe { *(record.function_queries[3].output_at(__i).as_ptr() as *const [G; OUT_3]) }; __ret }, _ => aiur_fn_3(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
-    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_37]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__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];
@@ -60762,7 +60950,7 @@ fn aiur_fn_724(
     if (__v_39 != __v_49) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64(), msg: Some("assumption tree: wrong tag4 variant".to_string()) });
     }
-    let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[723].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[723].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[723].bump_multiplicity(__i); } let __ret: [G; OUT_723] = unsafe { *(record.function_queries[723].output_at(__i).as_ptr() as *const [G; OUT_723]) }; __ret }, _ => aiur_fn_723(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__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];
@@ -60910,21 +61098,21 @@ fn aiur_fn_724(
     if (__v_89 != __v_32) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_32.as_canonical_u64(), msg: Some("assumption tree: recomputed merkle root != requested root".to_string()) });
     }
-    let __ret: [G; OUT_724] = [__v_51];
-    record.function_queries[724].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_729] = [__v_51];
+    record.function_queries[729].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_725: usize = 7;
-const IN_725: usize = 7;
-const OUT_725: usize = 6;
-fn aiur_fn_725(
-  inp: [G; IN_725],
+const INPUT_SIZE_730: usize = 7;
+const IN_730: usize = 7;
+const OUT_730: usize = 6;
+fn aiur_fn_730(
+  inp: [G; IN_730],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_725], ExecError> {
+) -> Result<[G; OUT_730], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60939,28 +61127,28 @@ fn aiur_fn_725(
     let __v_9: G = __loaded[2];
     match __v_7.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_725] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
-        record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_730] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6];
+        record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_10: G = G::from_u64(1);
-        let __r_arr: [G; OUT_788] = { let __args: [G; IN_788] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[788].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[788].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[788].bump_multiplicity(__i); } let __ret: [G; OUT_788] = unsafe { *(record.function_queries[788].output_at(__i).as_ptr() as *const [G; OUT_788]) }; __ret }, _ => aiur_fn_788(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_8, __v_10, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[793].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[793].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { *(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793]) }; __ret }, _ => aiur_fn_793(__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_725] = { let __args: [G; IN_725] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__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_725] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
-        record.function_queries[725].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_730] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22];
+        record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -60970,15 +61158,15 @@ fn aiur_fn_725(
   })
 }
 
-const INPUT_SIZE_726: usize = 7;
-const IN_726: usize = 7;
-const OUT_726: usize = 1;
-fn aiur_fn_726(
-  inp: [G; IN_726],
+const INPUT_SIZE_731: usize = 7;
+const IN_731: usize = 7;
+const OUT_731: usize = 1;
+fn aiur_fn_731(
+  inp: [G; IN_731],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_726], ExecError> {
+) -> Result<[G; OUT_731], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -60988,23 +61176,23 @@ fn aiur_fn_726(
     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_772] = { let __args: [G; IN_772] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
     let __v_8: G = __r_arr[0];
-    let __ret: [G; OUT_726] = [__v_8];
-    record.function_queries[726].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_731] = [__v_8];
+    record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_727: usize = 14;
-const IN_727: usize = 14;
-const OUT_727: usize = 0;
-fn aiur_fn_727(
-  inp: [G; IN_727],
+const INPUT_SIZE_732: usize = 14;
+const IN_732: usize = 14;
+const OUT_732: usize = 0;
+fn aiur_fn_732(
+  inp: [G; IN_732],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_727], ExecError> {
+) -> Result<[G; OUT_732], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61020,18 +61208,18 @@ fn aiur_fn_727(
     let __v_11: G = inp[11];
     let __v_12: G = inp[12];
     let __v_13: G = inp[13];
-    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i); } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[731].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[731].bump_multiplicity(__i); } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => aiur_fn_731(__args, record, io_buffer, __cu)? } };
     let __v_14: G = __r_arr[0];
     match __v_14.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_727] = [];
-        record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_732] = [];
+        record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
         let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_13.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[726].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[726].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[726].bump_multiplicity(__i); } let __ret: [G; OUT_726] = unsafe { *(record.function_queries[726].output_at(__i).as_ptr() as *const [G; OUT_726]) }; __ret }, _ => aiur_fn_726(__args, record, io_buffer, __cu)? } };
+    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]; let __cu = unconstrained; let __hit = record.function_queries[731].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[731].bump_multiplicity(__i); } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => aiur_fn_731(__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) {
@@ -61044,7 +61232,7 @@ fn aiur_fn_727(
   },
 }
  };
-        let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -61098,14 +61286,14 @@ fn aiur_fn_727(
             let __mc_out___mc_1: [G; 0] = '__mc_1: { match __v_15.as_canonical_u64() {
   8u64 => {
     let __v_63: G = G::from_u64(0);
-    let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[719].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[719].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[719].bump_multiplicity(__i); } let __ret: [G; OUT_719] = unsafe { *(record.function_queries[719].output_at(__i).as_ptr() as *const [G; OUT_719]) }; __ret }, _ => aiur_fn_719(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0, __v_16, __v_16, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
     break '__mc_1 [];
   },
   7u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__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; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
         break '__mc_1 [];
       },
     }
@@ -61113,8 +61301,8 @@ fn aiur_fn_727(
   6u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__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; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
         break '__mc_1 [];
       },
     }
@@ -61122,8 +61310,8 @@ fn aiur_fn_727(
   4u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__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; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
         break '__mc_1 [];
       },
     }
@@ -61131,24 +61319,24 @@ fn aiur_fn_727(
   5u64 => {
     match __v_16.as_canonical_u64() {
       _ => {
-        let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__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; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
         break '__mc_1 [];
       },
     }
   },
   _ => {
-    let __r_arr: [G; OUT_709] = { let __args: [G; IN_709] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[709].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[709].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[709].bump_multiplicity(__i); } let __ret: [G; OUT_709] = unsafe { *(record.function_queries[709].output_at(__i).as_ptr() as *const [G; OUT_709]) }; __ret }, _ => aiur_fn_709(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[714].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[714].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[714].bump_multiplicity(__i); } let __ret: [G; OUT_714] = unsafe { *(record.function_queries[714].output_at(__i).as_ptr() as *const [G; OUT_714]) }; __ret }, _ => aiur_fn_714(__args, record, io_buffer, __cu)? } };
     break '__mc_1 [];
   },
 }
  };
-            let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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; let __hit = record.function_queries[715].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[715].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[715].bump_multiplicity(__i); } let __ret: [G; OUT_715] = unsafe { *(record.function_queries[715].output_at(__i).as_ptr() as *const [G; OUT_715]) }; __ret }, _ => aiur_fn_715(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_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; let __hit = record.function_queries[720].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[720].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[720].bump_multiplicity(__i); } let __ret: [G; OUT_720] = unsafe { *(record.function_queries[720].output_at(__i).as_ptr() as *const [G; OUT_720]) }; __ret }, _ => aiur_fn_720(__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_728] = { let __args: [G; IN_728] = [__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; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_727] = [];
-            record.function_queries[727].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__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; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_732] = [];
+            record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -61157,15 +61345,15 @@ fn aiur_fn_727(
   })
 }
 
-const INPUT_SIZE_728: usize = 16;
-const IN_728: usize = 16;
-const OUT_728: usize = 0;
-fn aiur_fn_728(
-  inp: [G; IN_728],
+const INPUT_SIZE_733: usize = 16;
+const IN_733: usize = 16;
+const OUT_733: usize = 0;
+fn aiur_fn_733(
+  inp: [G; IN_733],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_728], ExecError> {
+) -> Result<[G; OUT_733], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61189,16 +61377,16 @@ fn aiur_fn_728(
     let __v_18: G = __loaded[2];
     match __v_16.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_728] = [];
-        record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_733] = [];
+        record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[716].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[716].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[716].bump_multiplicity(__i); } let __ret: [G; OUT_716] = unsafe { *(record.function_queries[716].output_at(__i).as_ptr() as *const [G; OUT_716]) }; __ret }, _ => aiur_fn_716(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[721].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[721].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[721].bump_multiplicity(__i); } let __ret: [G; OUT_721] = unsafe { *(record.function_queries[721].output_at(__i).as_ptr() as *const [G; OUT_721]) }; __ret }, _ => aiur_fn_721(__args, record, io_buffer, __cu)? } };
         let __v_19: G = __r_arr[0];
         let __mc_out___mc_0: [G; 0] = '__mc_0: { match __v_19.as_canonical_u64() {
   1u64 => {
-    let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__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; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
     break '__mc_0 [];
   },
   _ => {
@@ -61208,9 +61396,9 @@ fn aiur_fn_728(
  };
         let __v_20: G = G::from_u64(1);
         let __v_21: G = (__v_2 + __v_20);
-        let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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; let __hit = record.function_queries[728].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[728].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[728].bump_multiplicity(__i); } let __ret: [G; OUT_728] = unsafe { *(record.function_queries[728].output_at(__i).as_ptr() as *const [G; OUT_728]) }; __ret }, _ => aiur_fn_728(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_728] = [];
-        record.function_queries[728].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__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; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_733] = [];
+        record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -61220,15 +61408,15 @@ fn aiur_fn_728(
   })
 }
 
-const INPUT_SIZE_729: usize = 13;
-const IN_729: usize = 13;
-const OUT_729: usize = 0;
-fn aiur_fn_729(
-  inp: [G; IN_729],
+const INPUT_SIZE_734: usize = 13;
+const IN_734: usize = 13;
+const OUT_734: usize = 0;
+fn aiur_fn_734(
+  inp: [G; IN_734],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_729], ExecError> {
+) -> Result<[G; OUT_734], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61249,16 +61437,16 @@ fn aiur_fn_729(
     let __v_15: G = __loaded[2];
     match __v_13.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_729] = [];
-        record.function_queries[729].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_734] = [];
+        record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_16: G = G::from_u64(1);
-        let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__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; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__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; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_729] = [];
-        record.function_queries[729].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__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; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__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; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_734] = [];
+        record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -61268,20 +61456,20 @@ fn aiur_fn_729(
   })
 }
 
-const INPUT_SIZE_730: usize = 3;
-const IN_730: usize = 3;
-const OUT_730: usize = 0;
-fn aiur_fn_730(
-  inp: [G; IN_730],
+const INPUT_SIZE_735: usize = 3;
+const IN_735: usize = 3;
+const OUT_735: usize = 0;
+fn aiur_fn_735(
+  inp: [G; IN_735],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_730], ExecError> {
+) -> Result<[G; OUT_735], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_1.as_canonical_u64() {
   1u64 => {
@@ -61291,7 +61479,7 @@ fn aiur_fn_730(
     break '__mc_0 [__v_6];
   },
   0u64 => {
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     break '__mc_0 [__v_4];
   },
@@ -61303,7 +61491,7 @@ fn aiur_fn_730(
     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_725] = { let __args: [G; IN_725] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_3, __v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__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];
@@ -61312,49 +61500,49 @@ fn aiur_fn_730(
     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_725] = { let __args: [G; IN_725] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_4, __v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } };
     let __v_15: G = __r_arr[0];
     let __v_16: G = __r_arr[1];
     let __v_17: G = __r_arr[2];
     let __v_18: G = __r_arr[3];
     let __v_19: G = __r_arr[4];
     let __v_20: G = __r_arr[5];
-    let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__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; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_730] = [];
-    record.function_queries[730].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__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; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_735] = [];
+    record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_731: usize = 1;
-const IN_731: usize = 1;
-const OUT_731: usize = 3;
-fn aiur_fn_731(
-  inp: [G; IN_731],
+const INPUT_SIZE_736: usize = 1;
+const IN_736: usize = 1;
+const OUT_736: usize = 3;
+fn aiur_fn_736(
+  inp: [G; IN_736],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_731], ExecError> {
+) -> Result<[G; OUT_736], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
         let __v_3: G = G::from_u64(1);
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_731] = [__v_3, __v_4, __v_2];
-        record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_736] = [__v_3, __v_4, __v_2];
+        record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__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_731] = [__v_5, __v_3, __v_4];
-        record.function_queries[731].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_736] = [__v_5, __v_3, __v_4];
+        record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -61364,15 +61552,15 @@ fn aiur_fn_731(
   })
 }
 
-const INPUT_SIZE_732: usize = 2;
-const IN_732: usize = 2;
-const OUT_732: usize = 10;
-fn aiur_fn_732(
-  inp: [G; IN_732],
+const INPUT_SIZE_737: usize = 2;
+const IN_737: usize = 2;
+const OUT_737: usize = 10;
+fn aiur_fn_737(
+  inp: [G; IN_737],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_732], ExecError> {
+) -> Result<[G; OUT_737], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61380,12 +61568,12 @@ fn aiur_fn_732(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_732] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
-        record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_737] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1];
+        record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -61396,23 +61584,23 @@ fn aiur_fn_732(
         let __v_9: G = __r_arr[7];
         let __v_10: G = __r_arr[8];
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_732] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
-        record.function_queries[732].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_737] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10];
+        record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_733: usize = 2;
-const IN_733: usize = 2;
-const OUT_733: usize = 3;
-fn aiur_fn_733(
-  inp: [G; IN_733],
+const INPUT_SIZE_738: usize = 2;
+const IN_738: usize = 2;
+const OUT_738: usize = 3;
+fn aiur_fn_738(
+  inp: [G; IN_738],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_733], ExecError> {
+) -> Result<[G; OUT_738], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61420,32 +61608,32 @@ fn aiur_fn_733(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_733] = [__v_2, __v_3, __v_1];
-        record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_738] = [__v_2, __v_3, __v_1];
+        record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__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_733] = [__v_4, __v_2, __v_3];
-        record.function_queries[733].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_738] = [__v_4, __v_2, __v_3];
+        record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_734: usize = 2;
-const IN_734: usize = 2;
-const OUT_734: usize = 3;
-fn aiur_fn_734(
-  inp: [G; IN_734],
+const INPUT_SIZE_739: usize = 2;
+const IN_739: usize = 2;
+const OUT_739: usize = 3;
+fn aiur_fn_739(
+  inp: [G; IN_739],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_734], ExecError> {
+) -> Result<[G; OUT_739], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61453,32 +61641,32 @@ fn aiur_fn_734(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_734] = [__v_2, __v_3, __v_1];
-        record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_739] = [__v_2, __v_3, __v_1];
+        record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_734] = [__v_4, __v_2, __v_3];
-        record.function_queries[734].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_739] = [__v_4, __v_2, __v_3];
+        record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_735: usize = 2;
-const IN_735: usize = 2;
-const OUT_735: usize = 3;
-fn aiur_fn_735(
-  inp: [G; IN_735],
+const INPUT_SIZE_740: usize = 2;
+const IN_740: usize = 2;
+const OUT_740: usize = 3;
+fn aiur_fn_740(
+  inp: [G; IN_740],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_735], ExecError> {
+) -> Result<[G; OUT_740], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61486,34 +61674,34 @@ fn aiur_fn_735(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_735] = [__v_2, __v_3, __v_1];
-        record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_740] = [__v_2, __v_3, __v_1];
+        record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_735] = [__v_4, __v_5, __v_3];
-            record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_740] = [__v_4, __v_5, __v_3];
+            record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_735] = [__v_4, __v_5, __v_3];
-            record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_740] = [__v_4, __v_5, __v_3];
+            record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(2);
-            let __ret: [G; OUT_735] = [__v_4, __v_5, __v_3];
-            record.function_queries[735].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_740] = [__v_4, __v_5, __v_3];
+            record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -61525,15 +61713,15 @@ fn aiur_fn_735(
   })
 }
 
-const INPUT_SIZE_736: usize = 2;
-const IN_736: usize = 2;
-const OUT_736: usize = 3;
-fn aiur_fn_736(
-  inp: [G; IN_736],
+const INPUT_SIZE_741: usize = 2;
+const IN_741: usize = 2;
+const OUT_741: usize = 3;
+fn aiur_fn_741(
+  inp: [G; IN_741],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_736], ExecError> {
+) -> Result<[G; OUT_741], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61541,41 +61729,41 @@ fn aiur_fn_736(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_736] = [__v_2, __v_3, __v_1];
-        record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_741] = [__v_2, __v_3, __v_1];
+        record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         match __v_2.as_canonical_u64() {
           0u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(0);
-            let __ret: [G; OUT_736] = [__v_4, __v_5, __v_3];
-            record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_741] = [__v_4, __v_5, __v_3];
+            record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           1u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(1);
-            let __ret: [G; OUT_736] = [__v_4, __v_5, __v_3];
-            record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_741] = [__v_4, __v_5, __v_3];
+            record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           2u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(2);
-            let __ret: [G; OUT_736] = [__v_4, __v_5, __v_3];
-            record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_741] = [__v_4, __v_5, __v_3];
+            record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           3u64 => {
             let __v_4: G = G::from_u64(0);
             let __v_5: G = G::from_u64(3);
-            let __ret: [G; OUT_736] = [__v_4, __v_5, __v_3];
-            record.function_queries[736].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_741] = [__v_4, __v_5, __v_3];
+            record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -61587,15 +61775,15 @@ fn aiur_fn_736(
   })
 }
 
-const INPUT_SIZE_737: usize = 9;
-const IN_737: usize = 9;
-const OUT_737: usize = 2;
-fn aiur_fn_737(
-  inp: [G; IN_737],
+const INPUT_SIZE_742: usize = 9;
+const IN_742: usize = 9;
+const OUT_742: usize = 2;
+fn aiur_fn_742(
+  inp: [G; IN_742],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_737], ExecError> {
+) -> Result<[G; OUT_742], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61613,12 +61801,12 @@ fn aiur_fn_737(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_737] = [__v_12, __v_0];
-        record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_742] = [__v_12, __v_0];
+        record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[109].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[109].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[109].bump_multiplicity(__i); } let __ret: [G; OUT_109] = unsafe { *(record.function_queries[109].output_at(__i).as_ptr() as *const [G; OUT_109]) }; __ret }, _ => aiur_fn_109(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[114].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[114].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[114].bump_multiplicity(__i); } let __ret: [G; OUT_114] = unsafe { *(record.function_queries[114].output_at(__i).as_ptr() as *const [G; OUT_114]) }; __ret }, _ => aiur_fn_114(__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];
@@ -61646,28 +61834,28 @@ fn aiur_fn_737(
         let __v_33: G = __r_arr[5];
         let __v_34: G = __r_arr[6];
         let __v_35: G = __r_arr[7];
-        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_737] = [__v_39, __v_37];
-        record.function_queries[737].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_742] = [__v_39, __v_37];
+        record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_738: usize = 2;
-const IN_738: usize = 2;
-const OUT_738: usize = 3;
-fn aiur_fn_738(
-  inp: [G; IN_738],
+const INPUT_SIZE_743: usize = 2;
+const IN_743: usize = 2;
+const OUT_743: usize = 3;
+fn aiur_fn_743(
+  inp: [G; IN_743],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_738], ExecError> {
+) -> Result<[G; OUT_743], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61675,12 +61863,12 @@ fn aiur_fn_738(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_738] = [__v_2, __v_3, __v_1];
-        record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_743] = [__v_2, __v_3, __v_1];
+        record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -61690,30 +61878,30 @@ fn aiur_fn_738(
         let __v_8: G = __r_arr[6];
         let __v_9: G = __r_arr[7];
         let __v_10: G = __r_arr[8];
-        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_738] = [__v_13, __v_11, __v_12];
-        record.function_queries[738].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_743] = [__v_13, __v_11, __v_12];
+        record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_739: usize = 1;
-const IN_739: usize = 1;
-const OUT_739: usize = 41;
-fn aiur_fn_739(
-  inp: [G; IN_739],
+const INPUT_SIZE_744: usize = 1;
+const IN_744: usize = 1;
+const OUT_744: usize = 41;
+fn aiur_fn_744(
+  inp: [G; IN_744],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_739], ExecError> {
+) -> Result<[G; OUT_744], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -61732,11 +61920,11 @@ fn aiur_fn_739(
     let __v_15: G = __b1_out[5];
     let __v_16: G = __b1_out[6];
     let __v_17: G = __b1_out[7];
-    let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_10, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } };
     let __v_18: G = __r_arr[0];
     let __v_19: G = __r_arr[1];
     let __v_20: G = __r_arr[2];
-    let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_11, __v_20]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -61747,7 +61935,7 @@ fn aiur_fn_739(
     let __v_28: G = __r_arr[7];
     let __v_29: G = __r_arr[8];
     let __v_30: G = __r_arr[9];
-    let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_12, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -61758,7 +61946,7 @@ fn aiur_fn_739(
     let __v_38: G = __r_arr[7];
     let __v_39: G = __r_arr[8];
     let __v_40: G = __r_arr[9];
-    let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_13, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_13, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -61769,7 +61957,7 @@ fn aiur_fn_739(
     let __v_48: G = __r_arr[7];
     let __v_49: G = __r_arr[8];
     let __v_50: G = __r_arr[9];
-    let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_14, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_14, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -61780,28 +61968,28 @@ fn aiur_fn_739(
     let __v_58: G = __r_arr[7];
     let __v_59: G = __r_arr[8];
     let __v_60: G = __r_arr[9];
-    let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_15, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_15, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_739] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63];
-    record.function_queries[739].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_744] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63];
+    record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_740: usize = 1;
-const IN_740: usize = 1;
-const OUT_740: usize = 49;
-fn aiur_fn_740(
-  inp: [G; IN_740],
+const INPUT_SIZE_745: usize = 1;
+const IN_745: usize = 1;
+const OUT_745: usize = 49;
+fn aiur_fn_745(
+  inp: [G; IN_745],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_740], ExecError> {
+) -> Result<[G; OUT_745], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -61811,7 +61999,7 @@ fn aiur_fn_740(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__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];
@@ -61853,21 +62041,21 @@ fn aiur_fn_740(
     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_740] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50];
-    record.function_queries[740].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_745] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50];
+    record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_741: usize = 9;
-const IN_741: usize = 9;
-const OUT_741: usize = 2;
-fn aiur_fn_741(
-  inp: [G; IN_741],
+const INPUT_SIZE_746: usize = 9;
+const IN_746: usize = 9;
+const OUT_746: usize = 2;
+fn aiur_fn_746(
+  inp: [G; IN_746],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_741], ExecError> {
+) -> Result<[G; OUT_746], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61885,12 +62073,12 @@ fn aiur_fn_741(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_741] = [__v_12, __v_0];
-        record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_746] = [__v_12, __v_0];
+        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[745].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i); } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => aiur_fn_745(__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];
@@ -61949,28 +62137,28 @@ fn aiur_fn_741(
         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_741] = { let __args: [G; IN_741] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66]; let __cu = unconstrained; let __hit = record.function_queries[746].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => aiur_fn_746(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_741] = [__v_70, __v_68];
-        record.function_queries[741].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_746] = [__v_70, __v_68];
+        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_742: usize = 2;
-const IN_742: usize = 2;
-const OUT_742: usize = 3;
-fn aiur_fn_742(
-  inp: [G; IN_742],
+const INPUT_SIZE_747: usize = 2;
+const IN_747: usize = 2;
+const OUT_747: usize = 3;
+fn aiur_fn_747(
+  inp: [G; IN_747],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_742], ExecError> {
+) -> Result<[G; OUT_747], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -61978,12 +62166,12 @@ fn aiur_fn_742(
       0u64 => {
         let __v_2: G = G::from_u64(1);
         let __v_3: G = G::from_u64(1);
-        let __ret: [G; OUT_742] = [__v_2, __v_3, __v_1];
-        record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_747] = [__v_2, __v_3, __v_1];
+        record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_1]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
         let __v_2: G = __r_arr[0];
         let __v_3: G = __r_arr[1];
         let __v_4: G = __r_arr[2];
@@ -61993,33 +62181,33 @@ fn aiur_fn_742(
         let __v_8: G = __r_arr[6];
         let __v_9: G = __r_arr[7];
         let __v_10: G = __r_arr[8];
-        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; let __hit = record.function_queries[746].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => aiur_fn_746(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = G::from_u64(0);
-        let __ret: [G; OUT_742] = [__v_13, __v_11, __v_12];
-        record.function_queries[742].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_747] = [__v_13, __v_11, __v_12];
+        record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_743: usize = 1;
-const IN_743: usize = 1;
-const OUT_743: usize = 55;
-fn aiur_fn_743(
-  inp: [G; IN_743],
+const INPUT_SIZE_748: usize = 1;
+const IN_748: usize = 1;
+const OUT_748: usize = 55;
+fn aiur_fn_748(
+  inp: [G; IN_748],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_743], ExecError> {
+) -> Result<[G; OUT_748], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -62049,15 +62237,15 @@ fn aiur_fn_743(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__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_735] = { let __args: [G; IN_735] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__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_732] = { let __args: [G; IN_732] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62068,26 +62256,26 @@ fn aiur_fn_743(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_733] = { let __args: [G; IN_733] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_743] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49];
-        record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_748] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49];
+        record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__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_732] = { let __args: [G; IN_732] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62098,7 +62286,7 @@ fn aiur_fn_743(
         let __v_38: G = __r_arr[7];
         let __v_39: G = __r_arr[8];
         let __v_40: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62109,7 +62297,7 @@ fn aiur_fn_743(
         let __v_48: G = __r_arr[7];
         let __v_49: G = __r_arr[8];
         let __v_50: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_15, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_15, __v_50]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62120,30 +62308,30 @@ fn aiur_fn_743(
         let __v_58: G = __r_arr[7];
         let __v_59: G = __r_arr[8];
         let __v_60: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_16, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_16, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_742] = { let __args: [G; IN_742] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[742].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[742].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[742].bump_multiplicity(__i); } let __ret: [G; OUT_742] = unsafe { *(record.function_queries[742].output_at(__i).as_ptr() as *const [G; OUT_742]) }; __ret }, _ => aiur_fn_742(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[747].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i); } let __ret: [G; OUT_747] = unsafe { *(record.function_queries[747].output_at(__i).as_ptr() as *const [G; OUT_747]) }; __ret }, _ => aiur_fn_747(__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_743] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66];
-        record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_748] = [__v_67, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_64, __v_65, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_68, __v_66];
+        record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__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_734] = { let __args: [G; IN_734] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__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_732] = { let __args: [G; IN_732] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62154,7 +62342,7 @@ fn aiur_fn_743(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62165,7 +62353,7 @@ fn aiur_fn_743(
         let __v_51: G = __r_arr[7];
         let __v_52: G = __r_arr[8];
         let __v_53: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62176,7 +62364,7 @@ fn aiur_fn_743(
         let __v_61: G = __r_arr[7];
         let __v_62: G = __r_arr[8];
         let __v_63: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62187,7 +62375,7 @@ fn aiur_fn_743(
         let __v_71: G = __r_arr[7];
         let __v_72: G = __r_arr[8];
         let __v_73: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62198,17 +62386,17 @@ fn aiur_fn_743(
         let __v_81: G = __r_arr[7];
         let __v_82: G = __r_arr[8];
         let __v_83: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_738] = { let __args: [G; IN_738] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__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_743] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
-        record.function_queries[743].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_748] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
+        record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62218,18 +62406,18 @@ fn aiur_fn_743(
   })
 }
 
-const INPUT_SIZE_744: usize = 1;
-const IN_744: usize = 1;
-const OUT_744: usize = 63;
-fn aiur_fn_744(
-  inp: [G; IN_744],
+const INPUT_SIZE_749: usize = 1;
+const IN_749: usize = 1;
+const OUT_749: usize = 63;
+fn aiur_fn_749(
+  inp: [G; IN_749],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_744], ExecError> {
+) -> Result<[G; OUT_749], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
     let __v_3: G = __r_arr[2];
@@ -62239,7 +62427,7 @@ fn aiur_fn_744(
     let __v_7: G = __r_arr[6];
     let __v_8: G = __r_arr[7];
     let __v_9: G = __r_arr[8];
-    let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_9]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__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];
@@ -62295,21 +62483,21 @@ fn aiur_fn_744(
     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_744] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64];
-    record.function_queries[744].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_749] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64];
+    record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_745: usize = 9;
-const IN_745: usize = 9;
-const OUT_745: usize = 2;
-fn aiur_fn_745(
-  inp: [G; IN_745],
+const INPUT_SIZE_750: usize = 9;
+const IN_750: usize = 9;
+const OUT_750: usize = 2;
+fn aiur_fn_750(
+  inp: [G; IN_750],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_745], ExecError> {
+) -> Result<[G; OUT_750], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -62327,12 +62515,12 @@ fn aiur_fn_745(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_745] = [__v_12, __v_0];
-        record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_750] = [__v_12, __v_0];
+        record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
-        let __r_arr: [G; OUT_744] = { let __args: [G; IN_744] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[744].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[744].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[744].bump_multiplicity(__i); } let __ret: [G; OUT_744] = unsafe { *(record.function_queries[744].output_at(__i).as_ptr() as *const [G; OUT_744]) }; __ret }, _ => aiur_fn_744(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[749].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i); } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => aiur_fn_749(__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];
@@ -62405,34 +62593,34 @@ fn aiur_fn_745(
         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_745] = { let __args: [G; IN_745] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[745].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i); } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => aiur_fn_745(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80]; let __cu = unconstrained; let __hit = record.function_queries[750].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i); } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => aiur_fn_750(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_745] = [__v_84, __v_82];
-        record.function_queries[745].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_750] = [__v_84, __v_82];
+        record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_746: usize = 1;
-const IN_746: usize = 1;
-const OUT_746: usize = 55;
-fn aiur_fn_746(
-  inp: [G; IN_746],
+const INPUT_SIZE_751: usize = 1;
+const IN_751: usize = 1;
+const OUT_751: usize = 55;
+fn aiur_fn_751(
+  inp: [G; IN_751],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_746], ExecError> {
+) -> Result<[G; OUT_751], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
-    let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[74].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[74].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[74].bump_multiplicity(__i); } let __ret: [G; OUT_74] = unsafe { *(record.function_queries[74].output_at(__i).as_ptr() as *const [G; OUT_74]) }; __ret }, _ => aiur_fn_74(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_1: G = __r_arr[0];
     let __v_2: G = __r_arr[1];
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = __r_arr[1];
     let __v_5: G = __r_arr[2];
@@ -62462,15 +62650,15 @@ fn aiur_fn_746(
     let __v_27: G = __b1_out[7];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__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_735] = { let __args: [G; IN_735] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[740].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[740].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[740].bump_multiplicity(__i); } let __ret: [G; OUT_740] = unsafe { *(record.function_queries[740].output_at(__i).as_ptr() as *const [G; OUT_740]) }; __ret }, _ => aiur_fn_740(__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_732] = { let __args: [G; IN_732] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62481,30 +62669,30 @@ fn aiur_fn_746(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_733] = { let __args: [G; IN_733] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_16, __v_46]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__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_734] = { let __args: [G; IN_734] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__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_732] = { let __args: [G; IN_732] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_14, __v_33]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62515,7 +62703,7 @@ fn aiur_fn_746(
         let __v_41: G = __r_arr[7];
         let __v_42: G = __r_arr[8];
         let __v_43: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_15, __v_43]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62526,7 +62714,7 @@ fn aiur_fn_746(
         let __v_51: G = __r_arr[7];
         let __v_52: G = __r_arr[8];
         let __v_53: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_16, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62537,7 +62725,7 @@ fn aiur_fn_746(
         let __v_61: G = __r_arr[7];
         let __v_62: G = __r_arr[8];
         let __v_63: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_17, __v_63]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62548,7 +62736,7 @@ fn aiur_fn_746(
         let __v_71: G = __r_arr[7];
         let __v_72: G = __r_arr[8];
         let __v_73: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_18, __v_73]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62559,25 +62747,25 @@ fn aiur_fn_746(
         let __v_81: G = __r_arr[7];
         let __v_82: G = __r_arr[8];
         let __v_83: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_19, __v_83]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_738] = { let __args: [G; IN_738] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_743] = { let __args: [G; IN_743] = [__v_20, __v_86]; let __cu = unconstrained; let __hit = record.function_queries[743].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[743].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[743].bump_multiplicity(__i); } let __ret: [G; OUT_743] = unsafe { *(record.function_queries[743].output_at(__i).as_ptr() as *const [G; OUT_743]) }; __ret }, _ => aiur_fn_743(__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_746] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
-        let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[734].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[734].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[734].bump_multiplicity(__i); } let __ret: [G; OUT_734] = unsafe { *(record.function_queries[734].output_at(__i).as_ptr() as *const [G; OUT_734]) }; __ret }, _ => aiur_fn_734(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[739].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[739].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[739].bump_multiplicity(__i); } let __ret: [G; OUT_739] = unsafe { *(record.function_queries[739].output_at(__i).as_ptr() as *const [G; OUT_739]) }; __ret }, _ => aiur_fn_739(__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_732] = { let __args: [G; IN_732] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62588,22 +62776,22 @@ fn aiur_fn_746(
         let __v_38: G = __r_arr[7];
         let __v_39: G = __r_arr[8];
         let __v_40: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       3u64 => {
-        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[736].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[736].bump_multiplicity(__i); } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => aiur_fn_736(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_741] = { let __args: [G; IN_741] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[741].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[741].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[741].bump_multiplicity(__i); } let __ret: [G; OUT_741] = unsafe { *(record.function_queries[741].output_at(__i).as_ptr() as *const [G; OUT_741]) }; __ret }, _ => aiur_fn_741(__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_732] = { let __args: [G; IN_732] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_13, __v_30]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62614,18 +62802,18 @@ fn aiur_fn_746(
         let __v_38: G = __r_arr[7];
         let __v_39: G = __r_arr[8];
         let __v_40: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_14, __v_40]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       4u64 => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62636,7 +62824,7 @@ fn aiur_fn_746(
         let __v_35: G = __r_arr[7];
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62647,18 +62835,18 @@ fn aiur_fn_746(
         let __v_45: G = __r_arr[7];
         let __v_46: G = __r_arr[8];
         let __v_47: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_14, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_14, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       5u64 => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62669,18 +62857,18 @@ fn aiur_fn_746(
         let __v_35: G = __r_arr[7];
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62691,18 +62879,18 @@ fn aiur_fn_746(
         let __v_35: G = __r_arr[7];
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__v_12, __v_11]; let __cu = unconstrained; let __hit = record.function_queries[737].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[737].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[737].bump_multiplicity(__i); } let __ret: [G; OUT_737] = unsafe { *(record.function_queries[737].output_at(__i).as_ptr() as *const [G; OUT_737]) }; __ret }, _ => aiur_fn_737(__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];
@@ -62713,14 +62901,14 @@ fn aiur_fn_746(
         let __v_35: G = __r_arr[7];
         let __v_36: G = __r_arr[8];
         let __v_37: G = __r_arr[9];
-        let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[733].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[733].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[733].bump_multiplicity(__i); } let __ret: [G; OUT_733] = unsafe { *(record.function_queries[733].output_at(__i).as_ptr() as *const [G; OUT_733]) }; __ret }, _ => aiur_fn_733(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_13, __v_37]; let __cu = unconstrained; let __hit = record.function_queries[738].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[738].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[738].bump_multiplicity(__i); } let __ret: [G; OUT_738] = unsafe { *(record.function_queries[738].output_at(__i).as_ptr() as *const [G; OUT_738]) }; __ret }, _ => aiur_fn_738(__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_746] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       8u64 => {
@@ -62732,7 +62920,7 @@ fn aiur_fn_746(
     break '__mc_0 [__v_30, __v_11];
   },
   1u64 => {
-    let __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[76].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[76].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[76].bump_multiplicity(__i); } let __ret: [G; OUT_76] = unsafe { *(record.function_queries[76].output_at(__i).as_ptr() as *const [G; OUT_76]) }; __ret }, _ => aiur_fn_76(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[79].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[79].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[79].bump_multiplicity(__i); } let __ret: [G; OUT_79] = unsafe { *(record.function_queries[79].output_at(__i).as_ptr() as *const [G; OUT_79]) }; __ret }, _ => aiur_fn_79(__args, record, io_buffer, __cu)? } };
     let __v_28: G = __r_arr[0];
     let __v_29: G = __r_arr[1];
     let __v_30: G = __r_arr[2];
@@ -62742,7 +62930,7 @@ fn aiur_fn_746(
     let __v_34: G = __r_arr[6];
     let __v_35: G = __r_arr[7];
     let __v_36: G = __r_arr[8];
-    let __r_arr: [G; OUT_745] = { let __args: [G; IN_745] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[745].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[745].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[745].bump_multiplicity(__i); } let __ret: [G; OUT_745] = unsafe { *(record.function_queries[745].output_at(__i).as_ptr() as *const [G; OUT_745]) }; __ret }, _ => aiur_fn_745(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_36, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35]; let __cu = unconstrained; let __hit = record.function_queries[750].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i); } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => aiur_fn_750(__args, record, io_buffer, __cu)? } };
     let __v_37: G = __r_arr[0];
     let __v_38: G = __r_arr[1];
     break '__mc_0 [__v_37, __v_38];
@@ -62756,8 +62944,8 @@ fn aiur_fn_746(
         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_746] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29];
-        record.function_queries[746].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_751] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29];
+        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62767,15 +62955,15 @@ fn aiur_fn_746(
   })
 }
 
-const INPUT_SIZE_747: usize = 1;
-const IN_747: usize = 1;
-const OUT_747: usize = 1;
-fn aiur_fn_747(
-  inp: [G; IN_747],
+const INPUT_SIZE_752: usize = 1;
+const IN_752: usize = 1;
+const OUT_752: usize = 1;
+fn aiur_fn_752(
+  inp: [G; IN_752],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_747], ExecError> {
+) -> Result<[G; OUT_752], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr };
@@ -62804,40 +62992,40 @@ fn aiur_fn_747(
     let __v_22: G = __r_arr[0];
     let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_22]; let __cu = unconstrained; let __hit = record.function_queries[22].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[22].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[22].bump_multiplicity(__i); } let __ret: [G; OUT_22] = unsafe { *(record.function_queries[22].output_at(__i).as_ptr() as *const [G; OUT_22]) }; __ret }, _ => aiur_fn_22(__args, record, io_buffer, __cu)? } };
     let __v_23: G = __r_arr[0];
-    let __ret: [G; OUT_747] = [__v_23];
-    record.function_queries[747].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_752] = [__v_23];
+    record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_748: usize = 1;
-const IN_748: usize = 1;
-const OUT_748: usize = 1;
-fn aiur_fn_748(
-  inp: [G; IN_748],
+const INPUT_SIZE_753: usize = 1;
+const IN_753: usize = 1;
+const OUT_753: usize = 1;
+fn aiur_fn_753(
+  inp: [G; IN_753],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_748], ExecError> {
+) -> Result<[G; OUT_753], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     match __v_0.as_canonical_u64() {
       0u64 => {
         let __v_1: G = G::from_u64(0);
-        let __ret: [G; OUT_748] = [__v_1];
-        record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_753] = [__v_1];
+        record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       1u64 => {
         let __v_1: G = G::from_u64(1);
-        let __ret: [G; OUT_748] = [__v_1];
-        record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_753] = [__v_1];
+        record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       2u64 => {
         let __v_1: G = G::from_u64(2);
-        let __ret: [G; OUT_748] = [__v_1];
-        record.function_queries[748].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_753] = [__v_1];
+        record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62847,35 +63035,35 @@ fn aiur_fn_748(
   })
 }
 
-const INPUT_SIZE_749: usize = 3;
-const IN_749: usize = 3;
-const OUT_749: usize = 0;
-fn aiur_fn_749(
-  inp: [G; IN_749],
+const INPUT_SIZE_754: usize = 3;
+const IN_754: usize = 3;
+const OUT_754: usize = 0;
+fn aiur_fn_754(
+  inp: [G; IN_754],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_749], ExecError> {
+) -> Result<[G; OUT_754], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_749] = [];
-        record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_754] = [];
+        record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         if (__v_3 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition kind != real".to_string()) });
         }
-        let __ret: [G; OUT_749] = [];
-        record.function_queries[749].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_754] = [];
+        record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62885,35 +63073,35 @@ fn aiur_fn_749(
   })
 }
 
-const INPUT_SIZE_750: usize = 3;
-const IN_750: usize = 3;
-const OUT_750: usize = 0;
-fn aiur_fn_750(
-  inp: [G; IN_750],
+const INPUT_SIZE_755: usize = 3;
+const IN_755: usize = 3;
+const OUT_755: usize = 0;
+fn aiur_fn_755(
+  inp: [G; IN_755],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_750], ExecError> {
+) -> Result<[G; OUT_755], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_750] = [];
-        record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_755] = [];
+        record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_748] = { let __args: [G; IN_748] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[748].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[748].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[748].bump_multiplicity(__i); } let __ret: [G; OUT_748] = unsafe { *(record.function_queries[748].output_at(__i).as_ptr() as *const [G; OUT_748]) }; __ret }, _ => aiur_fn_748(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         if (__v_3 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed definition safety != real".to_string()) });
         }
-        let __ret: [G; OUT_750] = [];
-        record.function_queries[750].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_755] = [];
+        record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62923,35 +63111,35 @@ fn aiur_fn_750(
   })
 }
 
-const INPUT_SIZE_751: usize = 3;
-const IN_751: usize = 3;
-const OUT_751: usize = 0;
-fn aiur_fn_751(
-  inp: [G; IN_751],
+const INPUT_SIZE_756: usize = 3;
+const IN_756: usize = 3;
+const OUT_756: usize = 0;
+fn aiur_fn_756(
+  inp: [G; IN_756],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_751], ExecError> {
+) -> Result<[G; OUT_756], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_751] = [];
-        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } };
         let __v_3: G = __r_arr[0];
-        let __r_arr: [G; OUT_103] = { let __args: [G; IN_103] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[103].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[103].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[103].bump_multiplicity(__i); } let __ret: [G; OUT_103] = unsafe { *(record.function_queries[103].output_at(__i).as_ptr() as *const [G; OUT_103]) }; __ret }, _ => aiur_fn_103(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[108].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[108].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[108].bump_multiplicity(__i); } let __ret: [G; OUT_108] = unsafe { *(record.function_queries[108].output_at(__i).as_ptr() as *const [G; OUT_108]) }; __ret }, _ => aiur_fn_108(__args, record, io_buffer, __cu)? } };
         let __v_4: G = __r_arr[0];
         if (__v_3 != __v_4) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Reveal: claimed quotient kind != real".to_string()) });
         }
-        let __ret: [G; OUT_751] = [];
-        record.function_queries[751].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_756] = [];
+        record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62961,31 +63149,31 @@ fn aiur_fn_751(
   })
 }
 
-const INPUT_SIZE_752: usize = 3;
-const IN_752: usize = 3;
-const OUT_752: usize = 0;
-fn aiur_fn_752(
-  inp: [G; IN_752],
+const INPUT_SIZE_757: usize = 3;
+const IN_757: usize = 3;
+const OUT_757: usize = 0;
+fn aiur_fn_757(
+  inp: [G; IN_757],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_752], ExecError> {
+) -> Result<[G; OUT_757], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_752] = [];
-        record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_757] = [];
+        record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         if (__v_0 != __v_2) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64(), msg: Some("Reveal: claimed flag != real".to_string()) });
         }
-        let __ret: [G; OUT_752] = [];
-        record.function_queries[752].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_757] = [];
+        record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -62995,15 +63183,15 @@ fn aiur_fn_752(
   })
 }
 
-const INPUT_SIZE_753: usize = 17;
-const IN_753: usize = 17;
-const OUT_753: usize = 0;
-fn aiur_fn_753(
-  inp: [G; IN_753],
+const INPUT_SIZE_758: usize = 17;
+const IN_758: usize = 17;
+const OUT_758: usize = 0;
+fn aiur_fn_758(
+  inp: [G; IN_758],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_753], ExecError> {
+) -> Result<[G; OUT_758], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63024,8 +63212,8 @@ fn aiur_fn_753(
     let __v_16: G = inp[16];
     match __v_8.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_758] = [];
+        record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -63053,8 +63241,8 @@ fn aiur_fn_753(
         if (__v_7 != __v_16) {
           return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64(), msg: Some("Reveal: claimed numeric field != real".to_string()) });
         }
-        let __ret: [G; OUT_753] = [];
-        record.function_queries[753].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_758] = [];
+        record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -63064,23 +63252,23 @@ fn aiur_fn_753(
   })
 }
 
-const INPUT_SIZE_754: usize = 3;
-const IN_754: usize = 3;
-const OUT_754: usize = 0;
-fn aiur_fn_754(
-  inp: [G; IN_754],
+const INPUT_SIZE_759: usize = 3;
+const IN_759: usize = 3;
+const OUT_759: usize = 0;
+fn aiur_fn_759(
+  inp: [G; IN_759],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_754], ExecError> {
+) -> Result<[G; OUT_759], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_754] = [];
-        record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_759] = [];
+        record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -63246,8 +63434,8 @@ fn aiur_fn_754(
         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_754] = [];
-        record.function_queries[754].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_759] = [];
+        record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -63257,27 +63445,27 @@ fn aiur_fn_754(
   })
 }
 
-const INPUT_SIZE_755: usize = 3;
-const IN_755: usize = 3;
-const OUT_755: usize = 0;
-fn aiur_fn_755(
-  inp: [G; IN_755],
+const INPUT_SIZE_760: usize = 3;
+const IN_760: usize = 3;
+const OUT_760: usize = 0;
+fn aiur_fn_760(
+  inp: [G; IN_760],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_755], ExecError> {
+) -> Result<[G; OUT_760], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_755] = [];
-        record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_760] = [];
+        record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_747] = { let __args: [G; IN_747] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[747].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[747].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[747].bump_multiplicity(__i); } let __ret: [G; OUT_747] = unsafe { *(record.function_queries[747].output_at(__i).as_ptr() as *const [G; OUT_747]) }; __ret }, _ => aiur_fn_747(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr };
         let __v_4: G = __loaded[0];
@@ -63441,8 +63629,8 @@ fn aiur_fn_755(
         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_755] = [];
-        record.function_queries[755].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_760] = [];
+        record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -63452,15 +63640,15 @@ fn aiur_fn_755(
   })
 }
 
-const INPUT_SIZE_756: usize = 10;
-const IN_756: usize = 10;
-const OUT_756: usize = 0;
-fn aiur_fn_756(
-  inp: [G; IN_756],
+const INPUT_SIZE_761: usize = 10;
+const IN_761: usize = 10;
+const OUT_761: usize = 0;
+fn aiur_fn_761(
+  inp: [G; IN_761],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_756], ExecError> {
+) -> Result<[G; OUT_761], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63508,8 +63696,8 @@ fn aiur_fn_756(
         let __v_39: G = __loaded[10];
         match __v_29.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_756] = [];
-            record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_761] = [];
+            record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -63585,7 +63773,7 @@ fn aiur_fn_756(
                       return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_26.as_canonical_u64(), msg: Some("Reveal: claimed recursor rule field count != real".to_string()) });
                     }
                     let __v_40: G = G::from_u64(0);
-                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_38, __v_40, __v_27]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
                     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; let __hit = record.function_queries[15].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[15].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[15].bump_multiplicity(__i); } let __ret: [G; OUT_15] = unsafe { *(record.function_queries[15].output_at(__i).as_ptr() as *const [G; OUT_15]) }; __ret }, _ => aiur_fn_15(__args, record, io_buffer, __cu)? } };
                     let __v_41: G = __r_arr[0];
                     let __v_42: G = __r_arr[1];
@@ -63595,9 +63783,9 @@ fn aiur_fn_756(
                     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_756] = { let __args: [G; IN_756] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_756] = [];
-                    record.function_queries[756].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_39, __v_28, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_761] = [];
+                    record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -63616,23 +63804,23 @@ fn aiur_fn_756(
   })
 }
 
-const INPUT_SIZE_757: usize = 3;
-const IN_757: usize = 3;
-const OUT_757: usize = 0;
-fn aiur_fn_757(
-  inp: [G; IN_757],
+const INPUT_SIZE_762: usize = 3;
+const IN_762: usize = 3;
+const OUT_762: usize = 0;
+fn aiur_fn_762(
+  inp: [G; IN_762],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_757], ExecError> {
+) -> Result<[G; OUT_762], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_757] = [];
-        record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_762] = [];
+        record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -63644,9 +63832,9 @@ fn aiur_fn_757(
         let __v_8: G = G::from_u64(0);
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
-        let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_757] = [];
-        record.function_queries[757].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_761] = { let __args: [G; IN_761] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_762] = [];
+        record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -63656,15 +63844,15 @@ fn aiur_fn_757(
   })
 }
 
-const INPUT_SIZE_758: usize = 49;
-const IN_758: usize = 49;
-const OUT_758: usize = 0;
-fn aiur_fn_758(
-  inp: [G; IN_758],
+const INPUT_SIZE_763: usize = 49;
+const IN_763: usize = 49;
+const OUT_763: usize = 0;
+fn aiur_fn_763(
+  inp: [G; IN_763],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_758], ExecError> {
+) -> Result<[G; OUT_763], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63715,7 +63903,7 @@ fn aiur_fn_758(
     let __v_46: G = inp[46];
     let __v_47: G = inp[47];
     let __v_48: G = inp[48];
-    let __r_arr: [G; OUT_782] = { let __args: [G; IN_782] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; let __hit = record.function_queries[787].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[787].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { *(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787]) }; __ret }, _ => aiur_fn_787(__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];
@@ -63754,14 +63942,14 @@ fn aiur_fn_758(
       _ => {
         match __v_49.as_canonical_u64() {
           _ => {
-            let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-            let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_758] = [];
-            record.function_queries[758].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_763] = [];
+            record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -63770,15 +63958,15 @@ fn aiur_fn_758(
   })
 }
 
-const INPUT_SIZE_759: usize = 2;
-const IN_759: usize = 2;
-const OUT_759: usize = 0;
-fn aiur_fn_759(
-  inp: [G; IN_759],
+const INPUT_SIZE_764: usize = 2;
+const IN_764: usize = 2;
+const OUT_764: usize = 0;
+fn aiur_fn_764(
+  inp: [G; IN_764],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_759], ExecError> {
+) -> Result<[G; OUT_764], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -63835,15 +64023,15 @@ fn aiur_fn_759(
     let __v_51: G = __loaded[49];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_759] = [];
-        record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_764] = [];
+        record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_0, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_759] = [];
-        record.function_queries[759].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__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; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_51]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_764] = [];
+        record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -63853,29 +64041,29 @@ fn aiur_fn_759(
   })
 }
 
-const INPUT_SIZE_760: usize = 3;
-const IN_760: usize = 3;
-const OUT_760: usize = 0;
-fn aiur_fn_760(
-  inp: [G; IN_760],
+const INPUT_SIZE_765: usize = 3;
+const IN_765: usize = 3;
+const OUT_765: usize = 0;
+fn aiur_fn_765(
+  inp: [G; IN_765],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_760], ExecError> {
+) -> Result<[G; OUT_765], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_760] = [];
-        record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_765] = [];
+        record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_760] = [];
-        record.function_queries[760].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_0, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_765] = [];
+        record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -63885,15 +64073,15 @@ fn aiur_fn_760(
   })
 }
 
-const INPUT_SIZE_761: usize = 99;
-const IN_761: usize = 99;
-const OUT_761: usize = 0;
-fn aiur_fn_761(
-  inp: [G; IN_761],
+const INPUT_SIZE_766: usize = 99;
+const IN_766: usize = 99;
+const OUT_766: usize = 0;
+fn aiur_fn_766(
+  inp: [G; IN_766],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_761], ExecError> {
+) -> Result<[G; OUT_766], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64000,13 +64188,13 @@ fn aiur_fn_761(
           0u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[749].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i); } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => aiur_fn_749(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[750].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i); } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => aiur_fn_750(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_761] = [];
-                record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_766] = [];
+                record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -64021,14 +64209,14 @@ fn aiur_fn_761(
           1u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_761] = [];
-                record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_26, __v_75, __v_76]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_27, __v_77, __v_78]; let __cu = unconstrained; let __hit = record.function_queries[765].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => aiur_fn_765(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_766] = [];
+                record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -64043,17 +64231,17 @@ fn aiur_fn_761(
           2u64 => {
             match __v_1.as_canonical_u64() {
               _ => {
-                let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_761] = [];
-                record.function_queries[761].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67]; let __cu = unconstrained; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_766] = [];
+                record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -64070,15 +64258,15 @@ fn aiur_fn_761(
   })
 }
 
-const INPUT_SIZE_762: usize = 2;
-const IN_762: usize = 2;
-const OUT_762: usize = 0;
-fn aiur_fn_762(
-  inp: [G; IN_762],
+const INPUT_SIZE_767: usize = 2;
+const IN_767: usize = 2;
+const OUT_767: usize = 0;
+fn aiur_fn_767(
+  inp: [G; IN_767],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_762], ExecError> {
+) -> Result<[G; OUT_767], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64149,12 +64337,12 @@ fn aiur_fn_762(
     let __v_65: G = __loaded[63];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_762] = [];
-        record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_767] = [];
+        record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; let __hit = record.function_queries[784].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i); } let __ret: [G; OUT_784] = unsafe { *(record.function_queries[784].output_at(__i).as_ptr() as *const [G; OUT_784]) }; __ret }, _ => aiur_fn_784(__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];
@@ -64200,10 +64388,10 @@ fn aiur_fn_762(
         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_761] = { let __args: [G; IN_761] = [__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; let __hit = record.function_queries[761].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[761].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[761].bump_multiplicity(__i); } let __ret: [G; OUT_761] = unsafe { *(record.function_queries[761].output_at(__i).as_ptr() as *const [G; OUT_761]) }; __ret }, _ => aiur_fn_761(__args, record, io_buffer, __cu)? } };
-        let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_0, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_762] = [];
-        record.function_queries[762].finish(&inp[..], &__ret[..], !unconstrained);
+        let __r_arr: [G; OUT_766] = { let __args: [G; IN_766] = [__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; let __hit = record.function_queries[766].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[766].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[766].bump_multiplicity(__i); } let __ret: [G; OUT_766] = unsafe { *(record.function_queries[766].output_at(__i).as_ptr() as *const [G; OUT_766]) }; __ret }, _ => aiur_fn_766(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_0, __v_65]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_767] = [];
+        record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -64213,15 +64401,15 @@ fn aiur_fn_762(
   })
 }
 
-const INPUT_SIZE_763: usize = 55;
-const IN_763: usize = 55;
-const OUT_763: usize = 0;
-fn aiur_fn_763(
-  inp: [G; IN_763],
+const INPUT_SIZE_768: usize = 55;
+const IN_768: usize = 55;
+const OUT_768: usize = 0;
+fn aiur_fn_768(
+  inp: [G; IN_768],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_763], ExecError> {
+) -> Result<[G; OUT_768], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64278,7 +64466,7 @@ fn aiur_fn_763(
     let __v_52: G = inp[52];
     let __v_53: G = inp[53];
     let __v_54: G = inp[54];
-    let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[282].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[282].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[282].bump_multiplicity(__i); } let __ret: [G; OUT_282] = unsafe { *(record.function_queries[282].output_at(__i).as_ptr() as *const [G; OUT_282]) }; __ret }, _ => aiur_fn_282(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[287].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[287].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[287].bump_multiplicity(__i); } let __ret: [G; OUT_287] = unsafe { *(record.function_queries[287].output_at(__i).as_ptr() as *const [G; OUT_287]) }; __ret }, _ => aiur_fn_287(__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];
@@ -64335,13 +64523,13 @@ fn aiur_fn_763(
               0u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_749] = { let __args: [G; IN_749] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[749].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[749].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[749].bump_multiplicity(__i); } let __ret: [G; OUT_749] = unsafe { *(record.function_queries[749].output_at(__i).as_ptr() as *const [G; OUT_749]) }; __ret }, _ => aiur_fn_749(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_750] = { let __args: [G; IN_750] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[750].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[750].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[750].bump_multiplicity(__i); } let __ret: [G; OUT_750] = unsafe { *(record.function_queries[750].output_at(__i).as_ptr() as *const [G; OUT_750]) }; __ret }, _ => aiur_fn_750(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64356,17 +64544,17 @@ fn aiur_fn_763(
               1u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64381,11 +64569,11 @@ fn aiur_fn_763(
               2u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_752] = { let __args: [G; IN_752] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[752].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[752].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[752].bump_multiplicity(__i); } let __ret: [G; OUT_752] = unsafe { *(record.function_queries[752].output_at(__i).as_ptr() as *const [G; OUT_752]) }; __ret }, _ => aiur_fn_752(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_757] = { let __args: [G; IN_757] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[757].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[757].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[757].bump_multiplicity(__i); } let __ret: [G; OUT_757] = unsafe { *(record.function_queries[757].output_at(__i).as_ptr() as *const [G; OUT_757]) }; __ret }, _ => aiur_fn_757(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64400,11 +64588,11 @@ fn aiur_fn_763(
               3u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[751].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[751].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[751].bump_multiplicity(__i); } let __ret: [G; OUT_751] = unsafe { *(record.function_queries[751].output_at(__i).as_ptr() as *const [G; OUT_751]) }; __ret }, _ => aiur_fn_751(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_755] = { let __args: [G; IN_755] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[755].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[755].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[755].bump_multiplicity(__i); } let __ret: [G; OUT_755] = unsafe { *(record.function_queries[755].output_at(__i).as_ptr() as *const [G; OUT_755]) }; __ret }, _ => aiur_fn_755(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_756] = { let __args: [G; IN_756] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[756].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[756].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[756].bump_multiplicity(__i); } let __ret: [G; OUT_756] = unsafe { *(record.function_queries[756].output_at(__i).as_ptr() as *const [G; OUT_756]) }; __ret }, _ => aiur_fn_756(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_760] = { let __args: [G; IN_760] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; let __hit = record.function_queries[760].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[760].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[760].bump_multiplicity(__i); } let __ret: [G; OUT_760] = unsafe { *(record.function_queries[760].output_at(__i).as_ptr() as *const [G; OUT_760]) }; __ret }, _ => aiur_fn_760(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64419,11 +64607,11 @@ fn aiur_fn_763(
               4u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64438,10 +64626,10 @@ fn aiur_fn_763(
               5u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64456,10 +64644,10 @@ fn aiur_fn_763(
               6u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64474,10 +64662,10 @@ fn aiur_fn_763(
               7u64 => {
                 match __v_56.as_canonical_u64() {
                   _ => {
-                    let __r_arr: [G; OUT_753] = { let __args: [G; IN_753] = [__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; let __hit = record.function_queries[753].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[753].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[753].bump_multiplicity(__i); } let __ret: [G; OUT_753] = unsafe { *(record.function_queries[753].output_at(__i).as_ptr() as *const [G; OUT_753]) }; __ret }, _ => aiur_fn_753(__args, record, io_buffer, __cu)? } };
-                    let __r_arr: [G; OUT_754] = { let __args: [G; IN_754] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[754].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[754].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[754].bump_multiplicity(__i); } let __ret: [G; OUT_754] = unsafe { *(record.function_queries[754].output_at(__i).as_ptr() as *const [G; OUT_754]) }; __ret }, _ => aiur_fn_754(__args, record, io_buffer, __cu)? } };
-                    let __ret: [G; OUT_763] = [];
-                    record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __r_arr: [G; OUT_758] = { let __args: [G; IN_758] = [__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; let __hit = record.function_queries[758].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[758].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[758].bump_multiplicity(__i); } let __ret: [G; OUT_758] = unsafe { *(record.function_queries[758].output_at(__i).as_ptr() as *const [G; OUT_758]) }; __ret }, _ => aiur_fn_758(__args, record, io_buffer, __cu)? } };
+                    let __r_arr: [G; OUT_759] = { let __args: [G; IN_759] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; let __hit = record.function_queries[759].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[759].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[759].bump_multiplicity(__i); } let __ret: [G; OUT_759] = unsafe { *(record.function_queries[759].output_at(__i).as_ptr() as *const [G; OUT_759]) }; __ret }, _ => aiur_fn_759(__args, record, io_buffer, __cu)? } };
+                    let __ret: [G; OUT_768] = [];
+                    record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -64490,9 +64678,9 @@ fn aiur_fn_763(
           8u64 => {
             match __v_1.as_canonical_u64() {
               8u64 => {
-                let __r_arr: [G; OUT_762] = { let __args: [G; IN_762] = [__v_56, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[762].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[762].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[762].bump_multiplicity(__i); } let __ret: [G; OUT_762] = unsafe { *(record.function_queries[762].output_at(__i).as_ptr() as *const [G; OUT_762]) }; __ret }, _ => aiur_fn_762(__args, record, io_buffer, __cu)? } };
-                let __ret: [G; OUT_763] = [];
-                record.function_queries[763].finish(&inp[..], &__ret[..], !unconstrained);
+                let __r_arr: [G; OUT_767] = { let __args: [G; IN_767] = [__v_56, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[767].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[767].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[767].bump_multiplicity(__i); } let __ret: [G; OUT_767] = unsafe { *(record.function_queries[767].output_at(__i).as_ptr() as *const [G; OUT_767]) }; __ret }, _ => aiur_fn_767(__args, record, io_buffer, __cu)? } };
+                let __ret: [G; OUT_768] = [];
+                record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
@@ -64509,41 +64697,41 @@ fn aiur_fn_763(
   })
 }
 
-const INPUT_SIZE_764: usize = 2;
-const IN_764: usize = 2;
-const OUT_764: usize = 0;
-fn aiur_fn_764(
-  inp: [G; IN_764],
+const INPUT_SIZE_769: usize = 2;
+const IN_769: usize = 2;
+const OUT_769: usize = 0;
+fn aiur_fn_769(
+  inp: [G; IN_769],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_764], ExecError> {
+) -> Result<[G; OUT_769], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_0]; let __cu = unconstrained; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } };
     let __v_2: G = __r_arr[0];
-    let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[416].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[416].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[416].bump_multiplicity(__i); } let __ret: [G; OUT_416] = unsafe { *(record.function_queries[416].output_at(__i).as_ptr() as *const [G; OUT_416]) }; __ret }, _ => aiur_fn_416(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_1, __v_2]; let __cu = unconstrained; let __hit = record.function_queries[421].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[421].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[421].bump_multiplicity(__i); } let __ret: [G; OUT_421] = unsafe { *(record.function_queries[421].output_at(__i).as_ptr() as *const [G; OUT_421]) }; __ret }, _ => aiur_fn_421(__args, record, io_buffer, __cu)? } };
     let __v_3: G = __r_arr[0];
     let __v_4: G = G::from_u64(1);
     if (__v_3 != __v_4) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64(), msg: Some("Contains: target is not a leaf of the claimed tree".to_string()) });
     }
-    let __ret: [G; OUT_764] = [];
-    record.function_queries[764].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_769] = [];
+    record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_765: usize = 8;
-const IN_765: usize = 8;
-const OUT_765: usize = 0;
-fn aiur_fn_765(
-  inp: [G; IN_765],
+const INPUT_SIZE_770: usize = 8;
+const IN_770: usize = 8;
+const OUT_770: usize = 0;
+fn aiur_fn_770(
+  inp: [G; IN_770],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_765], ExecError> {
+) -> Result<[G; OUT_770], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64741,7 +64929,7 @@ fn aiur_fn_765(
     if (__v_167 != __v_7) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_167.as_canonical_u64(), rhs: __v_7.as_canonical_u64(), msg: Some("claim: bytes do not hash to the public claim digest".to_string()) });
     }
-    let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[78].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[78].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[78].bump_multiplicity(__i); } let __ret: [G; OUT_78] = unsafe { *(record.function_queries[78].output_at(__i).as_ptr() as *const [G; OUT_78]) }; __ret }, _ => aiur_fn_78(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_81] = { let __args: [G; IN_81] = [__v_12]; let __cu = unconstrained; let __hit = record.function_queries[81].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[81].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[81].bump_multiplicity(__i); } let __ret: [G; OUT_81] = unsafe { *(record.function_queries[81].output_at(__i).as_ptr() as *const [G; OUT_81]) }; __ret }, _ => aiur_fn_81(__args, record, io_buffer, __cu)? } };
     let __v_168: G = __r_arr[0];
     let __v_169: G = __r_arr[1];
     let __v_170: G = __r_arr[2];
@@ -64766,135 +64954,235 @@ fn aiur_fn_765(
     if (__v_184 != __v_185) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_184.as_canonical_u64(), rhs: __v_185.as_canonical_u64(), msg: Some("claim: tag4 size exceeds a single byte".to_string()) });
     }
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_177]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __v_186: G = __r_arr[0];
+    let __v_187: G = __r_arr[1];
+    let __v_188: G = G::from_u64(3);
+    if (__v_186 != __v_188) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_186.as_canonical_u64(), rhs: __v_188.as_canonical_u64(), msg: Some("claim: unsupported object format".to_string()) });
+    }
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
+    let __v_189: G = __r_arr[0];
+    let __v_190: G = __r_arr[1];
     match __v_169.as_canonical_u64() {
       4u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_177]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
-        let __v_186: G = __r_arr[0];
-        let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[731].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[731].bump_multiplicity(__i); } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => aiur_fn_731(__args, record, io_buffer, __cu)? } };
-        let __v_188: G = __r_arr[0];
-        let __v_189: G = __r_arr[1];
-        let __v_190: G = __r_arr[2];
-        match __v_188.as_canonical_u64() {
+        let __v_191: G = G::from_u64(1);
+        if (__v_189 != __v_191) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_191.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) });
+        }
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_190]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_192: G = __r_arr[0];
+        let __v_193: G = __r_arr[1];
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_193]; let __cu = unconstrained; let __hit = record.function_queries[736].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[736].bump_multiplicity(__i); } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => aiur_fn_736(__args, record, io_buffer, __cu)? } };
+        let __v_194: G = __r_arr[0];
+        let __v_195: G = __r_arr[1];
+        let __v_196: G = __r_arr[2];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_196.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_197: G = __loaded[0];
+        let __v_198: G = __loaded[1];
+        let __v_199: G = __loaded[2];
+        let __v_200: G = G::from_u64(1);
+        let __v_201: G = G::from_u64(1);
+        if (__v_197 != __v_200) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_200.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_198 != __v_201) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_201.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_199 != __v_201) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_199.as_canonical_u64(), rhs: __v_201.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        match __v_194.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_186]; let __cu = unconstrained; let __hit = record.function_queries[717].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[717].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[717].bump_multiplicity(__i); } let __ret: [G; OUT_717] = unsafe { *(record.function_queries[717].output_at(__i).as_ptr() as *const [G; OUT_717]) }; __ret }, _ => aiur_fn_717(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_765] = [];
-            record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_192]; let __cu = unconstrained; let __hit = record.function_queries[722].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[722].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[722].bump_multiplicity(__i); } let __ret: [G; OUT_722] = unsafe { *(record.function_queries[722].output_at(__i).as_ptr() as *const [G; OUT_722]) }; __ret }, _ => aiur_fn_722(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_770] = [];
+            record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
-            let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_189]; let __cu = unconstrained; let __hit = record.function_queries[724].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[724].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[724].bump_multiplicity(__i); } let __ret: [G; OUT_724] = unsafe { *(record.function_queries[724].output_at(__i).as_ptr() as *const [G; OUT_724]) }; __ret }, _ => aiur_fn_724(__args, record, io_buffer, __cu)? } };
-            let __v_191: G = __r_arr[0];
-            let __v_192: G = G::from_u64(1);
-            let __v_193: G = G::from_u64(1);
-            let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_191, __v_192, __v_193, __v_193, __v_193, __v_193, __v_193]; let __cu = unconstrained; let __hit = record.function_queries[725].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[725].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[725].bump_multiplicity(__i); } let __ret: [G; OUT_725] = unsafe { *(record.function_queries[725].output_at(__i).as_ptr() as *const [G; OUT_725]) }; __ret }, _ => aiur_fn_725(__args, record, io_buffer, __cu)? } };
-            let __v_194: G = __r_arr[0];
-            let __v_195: G = __r_arr[1];
-            let __v_196: G = __r_arr[2];
-            let __v_197: G = __r_arr[3];
-            let __v_198: G = __r_arr[4];
-            let __v_199: G = __r_arr[5];
-            let __v_200: G = G::from_u64(1);
-            let __v_201: G = G::from_u64(1);
-            let __v_202: G = G::from_u64(0);
-            let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_186, __v_200, __v_201, __v_201, __v_201, __v_201, __v_201, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_202]; let __cu = unconstrained; let __hit = record.function_queries[727].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[727].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[727].bump_multiplicity(__i); } let __ret: [G; OUT_727] = unsafe { *(record.function_queries[727].output_at(__i).as_ptr() as *const [G; OUT_727]) }; __ret }, _ => aiur_fn_727(__args, record, io_buffer, __cu)? } };
-            let __ret: [G; OUT_765] = [];
-            record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
+            let __r_arr: [G; OUT_729] = { let __args: [G; IN_729] = [__v_195]; let __cu = unconstrained; let __hit = record.function_queries[729].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[729].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[729].bump_multiplicity(__i); } let __ret: [G; OUT_729] = unsafe { *(record.function_queries[729].output_at(__i).as_ptr() as *const [G; OUT_729]) }; __ret }, _ => aiur_fn_729(__args, record, io_buffer, __cu)? } };
+            let __v_202: G = __r_arr[0];
+            let __v_203: G = G::from_u64(1);
+            let __v_204: G = G::from_u64(1);
+            let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_202, __v_203, __v_204, __v_204, __v_204, __v_204, __v_204]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } };
+            let __v_205: G = __r_arr[0];
+            let __v_206: G = __r_arr[1];
+            let __v_207: G = __r_arr[2];
+            let __v_208: G = __r_arr[3];
+            let __v_209: G = __r_arr[4];
+            let __v_210: G = __r_arr[5];
+            let __v_211: G = G::from_u64(1);
+            let __v_212: G = G::from_u64(1);
+            let __v_213: G = G::from_u64(0);
+            let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_192, __v_211, __v_212, __v_212, __v_212, __v_212, __v_212, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_213]; let __cu = unconstrained; let __hit = record.function_queries[732].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[732].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[732].bump_multiplicity(__i); } let __ret: [G; OUT_732] = unsafe { *(record.function_queries[732].output_at(__i).as_ptr() as *const [G; OUT_732]) }; __ret }, _ => aiur_fn_732(__args, record, io_buffer, __cu)? } };
+            let __ret: [G; OUT_770] = [];
+            record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
-            return Err(ExecError::MatchNoCase(__v_188.as_canonical_u64()));
+            return Err(ExecError::MatchNoCase(__v_194.as_canonical_u64()));
           },
         }
       },
       5u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_177]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
-        let __v_186: G = __r_arr[0];
-        let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[731].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[731].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[731].bump_multiplicity(__i); } let __ret: [G; OUT_731] = unsafe { *(record.function_queries[731].output_at(__i).as_ptr() as *const [G; OUT_731]) }; __ret }, _ => aiur_fn_731(__args, record, io_buffer, __cu)? } };
-        let __v_188: G = __r_arr[0];
-        let __v_189: G = __r_arr[1];
-        let __v_190: G = __r_arr[2];
-        let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_186, __v_188, __v_189]; let __cu = unconstrained; let __hit = record.function_queries[730].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[730].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[730].bump_multiplicity(__i); } let __ret: [G; OUT_730] = unsafe { *(record.function_queries[730].output_at(__i).as_ptr() as *const [G; OUT_730]) }; __ret }, _ => aiur_fn_730(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_765] = [];
-        record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
+        let __v_191: G = G::from_u64(1);
+        if (__v_189 != __v_191) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_191.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) });
+        }
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_190]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_192: G = __r_arr[0];
+        let __v_193: G = __r_arr[1];
+        let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_193]; let __cu = unconstrained; let __hit = record.function_queries[736].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[736].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[736].bump_multiplicity(__i); } let __ret: [G; OUT_736] = unsafe { *(record.function_queries[736].output_at(__i).as_ptr() as *const [G; OUT_736]) }; __ret }, _ => aiur_fn_736(__args, record, io_buffer, __cu)? } };
+        let __v_194: G = __r_arr[0];
+        let __v_195: G = __r_arr[1];
+        let __v_196: G = __r_arr[2];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_196.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_197: G = __loaded[0];
+        let __v_198: G = __loaded[1];
+        let __v_199: G = __loaded[2];
+        let __v_200: G = G::from_u64(1);
+        let __v_201: G = G::from_u64(1);
+        if (__v_197 != __v_200) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_200.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_198 != __v_201) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_201.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_199 != __v_201) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_199.as_canonical_u64(), rhs: __v_201.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_192, __v_194, __v_195]; let __cu = unconstrained; let __hit = record.function_queries[735].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[735].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[735].bump_multiplicity(__i); } let __ret: [G; OUT_735] = unsafe { *(record.function_queries[735].output_at(__i).as_ptr() as *const [G; OUT_735]) }; __ret }, _ => aiur_fn_735(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_770] = [];
+        record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       6u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_177]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
-        let __v_186: G = __r_arr[0];
-        let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_746] = { let __args: [G; IN_746] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[746].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[746].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[746].bump_multiplicity(__i); } let __ret: [G; OUT_746] = unsafe { *(record.function_queries[746].output_at(__i).as_ptr() as *const [G; OUT_746]) }; __ret }, _ => aiur_fn_746(__args, record, io_buffer, __cu)? } };
-        let __v_188: G = __r_arr[0];
-        let __v_189: G = __r_arr[1];
-        let __v_190: G = __r_arr[2];
-        let __v_191: G = __r_arr[3];
-        let __v_192: G = __r_arr[4];
-        let __v_193: G = __r_arr[5];
-        let __v_194: G = __r_arr[6];
-        let __v_195: G = __r_arr[7];
-        let __v_196: G = __r_arr[8];
-        let __v_197: G = __r_arr[9];
-        let __v_198: G = __r_arr[10];
-        let __v_199: G = __r_arr[11];
-        let __v_200: G = __r_arr[12];
-        let __v_201: G = __r_arr[13];
-        let __v_202: G = __r_arr[14];
-        let __v_203: G = __r_arr[15];
-        let __v_204: G = __r_arr[16];
-        let __v_205: G = __r_arr[17];
-        let __v_206: G = __r_arr[18];
-        let __v_207: G = __r_arr[19];
-        let __v_208: G = __r_arr[20];
-        let __v_209: G = __r_arr[21];
-        let __v_210: G = __r_arr[22];
-        let __v_211: G = __r_arr[23];
-        let __v_212: G = __r_arr[24];
-        let __v_213: G = __r_arr[25];
-        let __v_214: G = __r_arr[26];
-        let __v_215: G = __r_arr[27];
-        let __v_216: G = __r_arr[28];
-        let __v_217: G = __r_arr[29];
-        let __v_218: G = __r_arr[30];
-        let __v_219: G = __r_arr[31];
-        let __v_220: G = __r_arr[32];
-        let __v_221: G = __r_arr[33];
-        let __v_222: G = __r_arr[34];
-        let __v_223: G = __r_arr[35];
-        let __v_224: G = __r_arr[36];
-        let __v_225: G = __r_arr[37];
-        let __v_226: G = __r_arr[38];
-        let __v_227: G = __r_arr[39];
-        let __v_228: G = __r_arr[40];
-        let __v_229: G = __r_arr[41];
-        let __v_230: G = __r_arr[42];
-        let __v_231: G = __r_arr[43];
-        let __v_232: G = __r_arr[44];
-        let __v_233: G = __r_arr[45];
-        let __v_234: G = __r_arr[46];
-        let __v_235: G = __r_arr[47];
-        let __v_236: G = __r_arr[48];
-        let __v_237: G = __r_arr[49];
-        let __v_238: G = __r_arr[50];
-        let __v_239: G = __r_arr[51];
-        let __v_240: G = __r_arr[52];
-        let __v_241: G = __r_arr[53];
-        let __v_242: G = __r_arr[54];
-        let __r_arr: [G; OUT_763] = { let __args: [G; IN_763] = [__v_186, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __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]; let __cu = unconstrained; let __hit = record.function_queries[763].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[763].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[763].bump_multiplicity(__i); } let __ret: [G; OUT_763] = unsafe { *(record.function_queries[763].output_at(__i).as_ptr() as *const [G; OUT_763]) }; __ret }, _ => aiur_fn_763(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_765] = [];
-        record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
+        let __v_191: G = G::from_u64(0);
+        if (__v_189 != __v_191) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_191.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) });
+        }
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_190]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_192: G = __r_arr[0];
+        let __v_193: G = __r_arr[1];
+        let __r_arr: [G; OUT_751] = { let __args: [G; IN_751] = [__v_193]; let __cu = unconstrained; let __hit = record.function_queries[751].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[751].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[751].bump_multiplicity(__i); } let __ret: [G; OUT_751] = unsafe { *(record.function_queries[751].output_at(__i).as_ptr() as *const [G; OUT_751]) }; __ret }, _ => aiur_fn_751(__args, record, io_buffer, __cu)? } };
+        let __v_194: G = __r_arr[0];
+        let __v_195: G = __r_arr[1];
+        let __v_196: G = __r_arr[2];
+        let __v_197: G = __r_arr[3];
+        let __v_198: G = __r_arr[4];
+        let __v_199: G = __r_arr[5];
+        let __v_200: G = __r_arr[6];
+        let __v_201: G = __r_arr[7];
+        let __v_202: G = __r_arr[8];
+        let __v_203: G = __r_arr[9];
+        let __v_204: G = __r_arr[10];
+        let __v_205: G = __r_arr[11];
+        let __v_206: G = __r_arr[12];
+        let __v_207: G = __r_arr[13];
+        let __v_208: G = __r_arr[14];
+        let __v_209: G = __r_arr[15];
+        let __v_210: G = __r_arr[16];
+        let __v_211: G = __r_arr[17];
+        let __v_212: G = __r_arr[18];
+        let __v_213: G = __r_arr[19];
+        let __v_214: G = __r_arr[20];
+        let __v_215: G = __r_arr[21];
+        let __v_216: G = __r_arr[22];
+        let __v_217: G = __r_arr[23];
+        let __v_218: G = __r_arr[24];
+        let __v_219: G = __r_arr[25];
+        let __v_220: G = __r_arr[26];
+        let __v_221: G = __r_arr[27];
+        let __v_222: G = __r_arr[28];
+        let __v_223: G = __r_arr[29];
+        let __v_224: G = __r_arr[30];
+        let __v_225: G = __r_arr[31];
+        let __v_226: G = __r_arr[32];
+        let __v_227: G = __r_arr[33];
+        let __v_228: G = __r_arr[34];
+        let __v_229: G = __r_arr[35];
+        let __v_230: G = __r_arr[36];
+        let __v_231: G = __r_arr[37];
+        let __v_232: G = __r_arr[38];
+        let __v_233: G = __r_arr[39];
+        let __v_234: G = __r_arr[40];
+        let __v_235: G = __r_arr[41];
+        let __v_236: G = __r_arr[42];
+        let __v_237: G = __r_arr[43];
+        let __v_238: G = __r_arr[44];
+        let __v_239: G = __r_arr[45];
+        let __v_240: G = __r_arr[46];
+        let __v_241: G = __r_arr[47];
+        let __v_242: G = __r_arr[48];
+        let __v_243: G = __r_arr[49];
+        let __v_244: G = __r_arr[50];
+        let __v_245: G = __r_arr[51];
+        let __v_246: G = __r_arr[52];
+        let __v_247: G = __r_arr[53];
+        let __v_248: G = __r_arr[54];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_248.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_249: G = __loaded[0];
+        let __v_250: G = __loaded[1];
+        let __v_251: G = __loaded[2];
+        let __v_252: G = G::from_u64(1);
+        let __v_253: G = G::from_u64(1);
+        if (__v_249 != __v_252) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_249.as_canonical_u64(), rhs: __v_252.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_250 != __v_253) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_250.as_canonical_u64(), rhs: __v_253.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_251 != __v_253) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_251.as_canonical_u64(), rhs: __v_253.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_192, __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, __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, __v_246, __v_247]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_770] = [];
+        record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       7u64 => {
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_177]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
-        let __v_186: G = __r_arr[0];
-        let __v_187: G = __r_arr[1];
-        let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_187]; let __cu = unconstrained; let __hit = record.function_queries[89].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[89].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[89].bump_multiplicity(__i); } let __ret: [G; OUT_89] = unsafe { *(record.function_queries[89].output_at(__i).as_ptr() as *const [G; OUT_89]) }; __ret }, _ => aiur_fn_89(__args, record, io_buffer, __cu)? } };
-        let __v_188: G = __r_arr[0];
-        let __v_189: G = __r_arr[1];
-        let __r_arr: [G; OUT_764] = { let __args: [G; IN_764] = [__v_186, __v_188]; let __cu = unconstrained; let __hit = record.function_queries[764].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[764].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[764].bump_multiplicity(__i); } let __ret: [G; OUT_764] = unsafe { *(record.function_queries[764].output_at(__i).as_ptr() as *const [G; OUT_764]) }; __ret }, _ => aiur_fn_764(__args, record, io_buffer, __cu)? } };
-        let __ret: [G; OUT_765] = [];
-        record.function_queries[765].finish(&inp[..], &__ret[..], !unconstrained);
+        let __v_191: G = G::from_u64(0);
+        if (__v_189 != __v_191) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_191.as_canonical_u64(), msg: Some("claim: wrong validator identity".to_string()) });
+        }
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_190]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_192: G = __r_arr[0];
+        let __v_193: G = __r_arr[1];
+        let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_193]; let __cu = unconstrained; let __hit = record.function_queries[94].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[94].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[94].bump_multiplicity(__i); } let __ret: [G; OUT_94] = unsafe { *(record.function_queries[94].output_at(__i).as_ptr() as *const [G; OUT_94]) }; __ret }, _ => aiur_fn_94(__args, record, io_buffer, __cu)? } };
+        let __v_194: G = __r_arr[0];
+        let __v_195: G = __r_arr[1];
+        let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_195.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+        let __v_196: G = __loaded[0];
+        let __v_197: G = __loaded[1];
+        let __v_198: G = __loaded[2];
+        let __v_199: G = G::from_u64(1);
+        let __v_200: G = G::from_u64(1);
+        if (__v_196 != __v_199) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_196.as_canonical_u64(), rhs: __v_199.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_197 != __v_200) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_197.as_canonical_u64(), rhs: __v_200.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        if (__v_198 != __v_200) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_198.as_canonical_u64(), rhs: __v_200.as_canonical_u64(), msg: Some("claim: trailing bytes".to_string()) });
+        }
+        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_192, __v_194]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } };
+        let __ret: [G; OUT_770] = [];
+        record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
+        return Ok(__ret);
+      },
+      9u64 => {
+        let __v_191: G = G::from_u64(2);
+        if (__v_189 != __v_191) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_189.as_canonical_u64(), rhs: __v_191.as_canonical_u64(), msg: Some("claim: wrong resource validator identity".to_string()) });
+        }
+        let __v_192: G = G::from_u64(0);
+        let __v_193: G = G::from_u64(1);
+        if (__v_192 != __v_193) {
+          return Err(ExecError::AssertEqMismatch { lhs: __v_192.as_canonical_u64(), rhs: __v_193.as_canonical_u64(), msg: Some("claim: resource-v1 is not implemented by IxVM".to_string()) });
+        }
+        let __ret: [G; OUT_770] = [];
+        record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -64904,15 +65192,15 @@ fn aiur_fn_765(
   })
 }
 
-const INPUT_SIZE_766: usize = 8;
-const IN_766: usize = 8;
-const OUT_766: usize = 0;
-fn aiur_fn_766(
-  inp: [G; IN_766],
+const INPUT_SIZE_771: usize = 8;
+const IN_771: usize = 8;
+const OUT_771: usize = 0;
+fn aiur_fn_771(
+  inp: [G; IN_771],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_766], ExecError> {
+) -> Result<[G; OUT_771], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64922,27 +65210,27 @@ fn aiur_fn_766(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_765] = { let __args: [G; IN_765] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[765].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[765].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[765].bump_multiplicity(__i); } let __ret: [G; OUT_765] = unsafe { *(record.function_queries[765].output_at(__i).as_ptr() as *const [G; OUT_765]) }; __ret }, _ => aiur_fn_765(__args, record, io_buffer, __cu)? } };
-    let __ret: [G; OUT_766] = [];
-    record.function_queries[766].finish(&inp[..], &__ret[..], !unconstrained);
+    let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } };
+    let __ret: [G; OUT_771] = [];
+    record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_767: usize = 3;
-const IN_767: usize = 3;
-const OUT_767: usize = 1;
-fn aiur_fn_767(
-  inp: [G; IN_767],
+const INPUT_SIZE_772: usize = 3;
+const IN_772: usize = 3;
+const OUT_772: usize = 1;
+fn aiur_fn_772(
+  inp: [G; IN_772],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_767], ExecError> {
+) -> Result<[G; OUT_772], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     let __v_2: G = inp[2];
-    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_4: G = __loaded[0];
@@ -64950,13 +65238,13 @@ fn aiur_fn_767(
     let __v_6: G = __loaded[2];
     match __v_4.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_767] = [__v_2];
-        record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_772] = [__v_2];
+        record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __ret: [G; OUT_767] = [__v_5];
-        record.function_queries[767].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_772] = [__v_5];
+        record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -64966,15 +65254,15 @@ fn aiur_fn_767(
   })
 }
 
-const INPUT_SIZE_768: usize = 2;
-const IN_768: usize = 2;
-const OUT_768: usize = 1;
-fn aiur_fn_768(
-  inp: [G; IN_768],
+const INPUT_SIZE_773: usize = 2;
+const IN_773: usize = 2;
+const OUT_773: usize = 1;
+fn aiur_fn_773(
+  inp: [G; IN_773],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_768], ExecError> {
+) -> Result<[G; OUT_773], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -64989,17 +65277,17 @@ fn aiur_fn_768(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_768] = [__v_9];
-        record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_773] = [__v_9];
+        record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_768] = { let __args: [G; IN_768] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[768].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[768].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[768].bump_multiplicity(__i); } let __ret: [G; OUT_768] = unsafe { *(record.function_queries[768].output_at(__i).as_ptr() as *const [G; OUT_768]) }; __ret }, _ => aiur_fn_768(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_773] = { let __args: [G; IN_773] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[773].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[773].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[773].bump_multiplicity(__i); } let __ret: [G; OUT_773] = unsafe { *(record.function_queries[773].output_at(__i).as_ptr() as *const [G; OUT_773]) }; __ret }, _ => aiur_fn_773(__args, record, io_buffer, __cu)? } };
         let __v_6: G = __r_arr[0];
         let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_768] = [__v_7];
-        record.function_queries[768].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_773] = [__v_7];
+        record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65009,15 +65297,15 @@ fn aiur_fn_768(
   })
 }
 
-const INPUT_SIZE_769: usize = 1;
-const IN_769: usize = 1;
-const OUT_769: usize = 8;
-fn aiur_fn_769(
-  inp: [G; IN_769],
+const INPUT_SIZE_774: usize = 1;
+const IN_774: usize = 1;
+const OUT_774: usize = 8;
+fn aiur_fn_774(
+  inp: [G; IN_774],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_769], ExecError> {
+) -> Result<[G; OUT_774], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -65041,12 +65329,12 @@ fn aiur_fn_769(
         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_769] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
-        record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_774] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18];
+        record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_769] = { let __args: [G; IN_769] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[769].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[769].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[769].bump_multiplicity(__i); } let __ret: [G; OUT_769] = unsafe { *(record.function_queries[769].output_at(__i).as_ptr() as *const [G; OUT_769]) }; __ret }, _ => aiur_fn_769(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = __r_arr[1];
         let __v_13: G = __r_arr[2];
@@ -65064,8 +65352,8 @@ fn aiur_fn_769(
         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_769] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
-        record.function_queries[769].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_774] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26];
+        record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65075,15 +65363,15 @@ fn aiur_fn_769(
   })
 }
 
-const INPUT_SIZE_770: usize = 2;
-const IN_770: usize = 2;
-const OUT_770: usize = 1;
-fn aiur_fn_770(
-  inp: [G; IN_770],
+const INPUT_SIZE_775: usize = 2;
+const IN_775: usize = 2;
+const OUT_775: usize = 1;
+fn aiur_fn_775(
+  inp: [G; IN_775],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_770], ExecError> {
+) -> Result<[G; OUT_775], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65094,17 +65382,17 @@ fn aiur_fn_770(
     let __v_5: G = __loaded[3];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_770] = [__v_1];
-        record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_775] = [__v_1];
+        record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_6: G = G::from_u64(0);
-        let __r_arr: [G; OUT_770] = { let __args: [G; IN_770] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[770].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[770].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[770].bump_multiplicity(__i); } let __ret: [G; OUT_770] = unsafe { *(record.function_queries[770].output_at(__i).as_ptr() as *const [G; OUT_770]) }; __ret }, _ => aiur_fn_770(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_5, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_770] = [__v_8];
-        record.function_queries[770].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_775] = [__v_8];
+        record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65114,15 +65402,15 @@ fn aiur_fn_770(
   })
 }
 
-const INPUT_SIZE_771: usize = 1;
-const IN_771: usize = 1;
-const OUT_771: usize = 8;
-fn aiur_fn_771(
-  inp: [G; IN_771],
+const INPUT_SIZE_776: usize = 1;
+const IN_776: usize = 1;
+const OUT_776: usize = 8;
+fn aiur_fn_776(
+  inp: [G; IN_776],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_771], ExecError> {
+) -> Result<[G; OUT_776], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -65139,12 +65427,12 @@ fn aiur_fn_771(
         let __v_9: G = G::from_u64(0);
         let __v_10: G = G::from_u64(0);
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_771] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
-        record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_776] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11];
+        record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_771] = { let __args: [G; IN_771] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[771].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[771].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[771].bump_multiplicity(__i); } let __ret: [G; OUT_771] = unsafe { *(record.function_queries[771].output_at(__i).as_ptr() as *const [G; OUT_771]) }; __ret }, _ => aiur_fn_771(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__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];
@@ -65162,8 +65450,8 @@ fn aiur_fn_771(
         let __v_17: G = __r_arr[5];
         let __v_18: G = __r_arr[6];
         let __v_19: G = __r_arr[7];
-        let __ret: [G; OUT_771] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[771].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_776] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65173,15 +65461,15 @@ fn aiur_fn_771(
   })
 }
 
-const INPUT_SIZE_772: usize = 8;
-const IN_772: usize = 8;
-const OUT_772: usize = 1;
-fn aiur_fn_772(
-  inp: [G; IN_772],
+const INPUT_SIZE_777: usize = 8;
+const IN_777: usize = 8;
+const OUT_777: usize = 1;
+fn aiur_fn_777(
+  inp: [G; IN_777],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_772], ExecError> {
+) -> Result<[G; OUT_777], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65193,8 +65481,8 @@ fn aiur_fn_772(
     let __v_7: G = inp[7];
     match __v_1.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_772] = [__v_7];
-        record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_777] = [__v_7];
+        record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -65215,25 +65503,25 @@ fn aiur_fn_772(
         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_772] = { let __args: [G; IN_772] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
             let __v_21: G = __r_arr[0];
-            let __ret: [G; OUT_772] = [__v_21];
-            record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_777] = [__v_21];
+            record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
             let __v_21: G = (__v_0 - __v_3);
             match __v_21.as_canonical_u64() {
               0u64 => {
-                let __ret: [G; OUT_772] = [__v_4];
-                record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_777] = [__v_4];
+                record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_772] = { let __args: [G; IN_772] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[772].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[772].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[772].bump_multiplicity(__i); } let __ret: [G; OUT_772] = unsafe { *(record.function_queries[772].output_at(__i).as_ptr() as *const [G; OUT_772]) }; __ret }, _ => aiur_fn_772(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_777] = { let __args: [G; IN_777] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[777].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[777].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[777].bump_multiplicity(__i); } let __ret: [G; OUT_777] = unsafe { *(record.function_queries[777].output_at(__i).as_ptr() as *const [G; OUT_777]) }; __ret }, _ => aiur_fn_777(__args, record, io_buffer, __cu)? } };
                 let __v_22: G = __r_arr[0];
-                let __ret: [G; OUT_772] = [__v_22];
-                record.function_queries[772].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_777] = [__v_22];
+                record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -65247,37 +65535,37 @@ fn aiur_fn_772(
   })
 }
 
-const INPUT_SIZE_773: usize = 1;
-const IN_773: usize = 1;
-const OUT_773: usize = 1;
-fn aiur_fn_773(
-  inp: [G; IN_773],
+const INPUT_SIZE_778: usize = 1;
+const IN_778: usize = 1;
+const OUT_778: usize = 1;
+fn aiur_fn_778(
+  inp: [G; IN_778],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_773], ExecError> {
+) -> Result<[G; OUT_778], 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-    let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[795].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[795].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { *(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795]) }; __ret }, _ => aiur_fn_795(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
-    let __ret: [G; OUT_773] = [__v_4];
-    record.function_queries[773].finish(&inp[..], &__ret[..], !unconstrained);
+    let __ret: [G; OUT_778] = [__v_4];
+    record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
 }
 
-const INPUT_SIZE_774: usize = 2;
-const IN_774: usize = 2;
-const OUT_774: usize = 1;
-fn aiur_fn_774(
-  inp: [G; IN_774],
+const INPUT_SIZE_779: usize = 2;
+const IN_779: usize = 2;
+const OUT_779: usize = 1;
+fn aiur_fn_779(
+  inp: [G; IN_779],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_774], ExecError> {
+) -> Result<[G; OUT_779], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65287,17 +65575,17 @@ fn aiur_fn_774(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_774] = [__v_1];
-        record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_779] = [__v_1];
+        record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_5: G = G::from_u64(0);
-        let __r_arr: [G; OUT_774] = { let __args: [G; IN_774] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[774].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[774].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[774].bump_multiplicity(__i); } let __ret: [G; OUT_774] = unsafe { *(record.function_queries[774].output_at(__i).as_ptr() as *const [G; OUT_774]) }; __ret }, _ => aiur_fn_774(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_779] = { let __args: [G; IN_779] = [__v_4, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_774] = [__v_7];
-        record.function_queries[774].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_779] = [__v_7];
+        record.function_queries[779].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65307,15 +65595,15 @@ fn aiur_fn_774(
   })
 }
 
-const INPUT_SIZE_775: usize = 1;
-const IN_775: usize = 1;
-const OUT_775: usize = 1;
-fn aiur_fn_775(
-  inp: [G; IN_775],
+const INPUT_SIZE_780: usize = 1;
+const IN_780: usize = 1;
+const OUT_780: usize = 1;
+fn aiur_fn_780(
+  inp: [G; IN_780],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_775], ExecError> {
+) -> Result<[G; OUT_780], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -65325,17 +65613,17 @@ fn aiur_fn_775(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_775] = [__v_4];
-        record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_780] = [__v_4];
+        record.function_queries[780].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_775] = { let __args: [G; IN_775] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[775].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[775].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[775].bump_multiplicity(__i); } let __ret: [G; OUT_775] = unsafe { *(record.function_queries[775].output_at(__i).as_ptr() as *const [G; OUT_775]) }; __ret }, _ => aiur_fn_775(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_3]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__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_775] = [__v_6];
-        record.function_queries[775].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_780] = [__v_6];
+        record.function_queries[780].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65345,15 +65633,15 @@ fn aiur_fn_775(
   })
 }
 
-const INPUT_SIZE_776: usize = 1;
-const IN_776: usize = 1;
-const OUT_776: usize = 8;
-fn aiur_fn_776(
-  inp: [G; IN_776],
+const INPUT_SIZE_781: usize = 1;
+const IN_781: usize = 1;
+const OUT_781: usize = 8;
+fn aiur_fn_781(
+  inp: [G; IN_781],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_776], ExecError> {
+) -> Result<[G; OUT_781], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 36 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 36] = __args[..36].try_into().unwrap(); __arr };
@@ -65403,12 +65691,12 @@ fn aiur_fn_776(
         let __v_42: G = G::from_u64(0);
         let __v_43: G = G::from_u64(0);
         let __v_44: G = G::from_u64(0);
-        let __ret: [G; OUT_776] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
-        record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_781] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44];
+        record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_776] = { let __args: [G; IN_776] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[776].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[776].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[776].bump_multiplicity(__i); } let __ret: [G; OUT_776] = unsafe { *(record.function_queries[776].output_at(__i).as_ptr() as *const [G; OUT_776]) }; __ret }, _ => aiur_fn_776(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_36]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__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];
@@ -65426,8 +65714,8 @@ fn aiur_fn_776(
         let __v_50: G = __r_arr[5];
         let __v_51: G = __r_arr[6];
         let __v_52: G = __r_arr[7];
-        let __ret: [G; OUT_776] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
-        record.function_queries[776].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_781] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52];
+        record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65437,19 +65725,19 @@ fn aiur_fn_776(
   })
 }
 
-const INPUT_SIZE_777: usize = 2;
-const IN_777: usize = 2;
-const OUT_777: usize = 1;
-fn aiur_fn_777(
-  inp: [G; IN_777],
+const INPUT_SIZE_782: usize = 2;
+const IN_782: usize = 2;
+const OUT_782: usize = 1;
+fn aiur_fn_782(
+  inp: [G; IN_782],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_777], ExecError> {
+) -> Result<[G; OUT_782], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
-    let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_1]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
     let __v_3: G = __loaded[0];
@@ -65457,8 +65745,8 @@ fn aiur_fn_777(
     let __v_5: G = __loaded[2];
     match __v_3.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_777] = [__v_4];
-        record.function_queries[777].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_782] = [__v_4];
+        record.function_queries[782].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65468,15 +65756,15 @@ fn aiur_fn_777(
   })
 }
 
-const INPUT_SIZE_778: usize = 1;
-const IN_778: usize = 1;
-const OUT_778: usize = 1;
-fn aiur_fn_778(
-  inp: [G; IN_778],
+const INPUT_SIZE_783: usize = 1;
+const IN_783: usize = 1;
+const OUT_783: usize = 1;
+fn aiur_fn_783(
+  inp: [G; IN_783],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_778], ExecError> {
+) -> Result<[G; OUT_783], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr };
@@ -65493,17 +65781,17 @@ fn aiur_fn_778(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_11: G = G::from_u64(0);
-        let __ret: [G; OUT_778] = [__v_11];
-        record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_783] = [__v_11];
+        record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_778] = { let __args: [G; IN_778] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[778].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[778].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[778].bump_multiplicity(__i); } let __ret: [G; OUT_778] = unsafe { *(record.function_queries[778].output_at(__i).as_ptr() as *const [G; OUT_778]) }; __ret }, _ => aiur_fn_778(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_783] = { let __args: [G; IN_783] = [__v_10]; let __cu = unconstrained; let __hit = record.function_queries[783].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[783].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[783].bump_multiplicity(__i); } let __ret: [G; OUT_783] = unsafe { *(record.function_queries[783].output_at(__i).as_ptr() as *const [G; OUT_783]) }; __ret }, _ => aiur_fn_783(__args, record, io_buffer, __cu)? } };
         let __v_11: G = __r_arr[0];
         let __v_12: G = G::from_u64(1);
         let __v_13: G = (__v_11 + __v_12);
-        let __ret: [G; OUT_778] = [__v_13];
-        record.function_queries[778].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_783] = [__v_13];
+        record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65513,15 +65801,15 @@ fn aiur_fn_778(
   })
 }
 
-const INPUT_SIZE_779: usize = 9;
-const IN_779: usize = 9;
-const OUT_779: usize = 45;
-fn aiur_fn_779(
-  inp: [G; IN_779],
+const INPUT_SIZE_784: usize = 9;
+const IN_784: usize = 9;
+const OUT_784: usize = 45;
+fn aiur_fn_784(
+  inp: [G; IN_784],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_779], ExecError> {
+) -> Result<[G; OUT_784], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65586,8 +65874,8 @@ fn aiur_fn_779(
         let __v_56: G = __r_arr[0];
         match __v_56.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_779] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[779].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_784] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __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[784].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -65600,7 +65888,7 @@ fn aiur_fn_779(
             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_779] = { let __args: [G; IN_779] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[779].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[779].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[779].bump_multiplicity(__i); } let __ret: [G; OUT_779] = unsafe { *(record.function_queries[779].output_at(__i).as_ptr() as *const [G; OUT_779]) }; __ret }, _ => aiur_fn_779(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __cu = unconstrained; let __hit = record.function_queries[784].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i); } let __ret: [G; OUT_784] = unsafe { *(record.function_queries[784].output_at(__i).as_ptr() as *const [G; OUT_784]) }; __ret }, _ => aiur_fn_784(__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];
@@ -65646,8 +65934,8 @@ fn aiur_fn_779(
             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_779] = [__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[779].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_784] = [__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[784].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -65662,15 +65950,15 @@ fn aiur_fn_779(
   })
 }
 
-const INPUT_SIZE_780: usize = 1;
-const IN_780: usize = 1;
-const OUT_780: usize = 8;
-fn aiur_fn_780(
-  inp: [G; IN_780],
+const INPUT_SIZE_785: usize = 1;
+const IN_785: usize = 1;
+const OUT_785: usize = 8;
+fn aiur_fn_785(
+  inp: [G; IN_785],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_780], ExecError> {
+) -> Result<[G; OUT_785], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 47 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 47] = __args[..47].try_into().unwrap(); __arr };
@@ -65731,12 +66019,12 @@ fn aiur_fn_780(
         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_780] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
-        record.function_queries[780].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_785] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55];
+        record.function_queries[785].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_780] = { let __args: [G; IN_780] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[780].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[780].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[780].bump_multiplicity(__i); } let __ret: [G; OUT_780] = unsafe { *(record.function_queries[780].output_at(__i).as_ptr() as *const [G; OUT_780]) }; __ret }, _ => aiur_fn_780(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_785] = { let __args: [G; IN_785] = [__v_47]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__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];
@@ -65754,8 +66042,8 @@ fn aiur_fn_780(
         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_780] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
-        record.function_queries[780].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_785] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63];
+        record.function_queries[785].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65765,15 +66053,15 @@ fn aiur_fn_780(
   })
 }
 
-const INPUT_SIZE_781: usize = 1;
-const IN_781: usize = 1;
-const OUT_781: usize = 8;
-fn aiur_fn_781(
-  inp: [G; IN_781],
+const INPUT_SIZE_786: usize = 1;
+const IN_786: usize = 1;
+const OUT_786: usize = 8;
+fn aiur_fn_786(
+  inp: [G; IN_786],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_781], ExecError> {
+) -> Result<[G; OUT_786], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr };
@@ -65798,12 +66086,12 @@ fn aiur_fn_781(
         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_781] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
-        record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_786] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19];
+        record.function_queries[786].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_781] = { let __args: [G; IN_781] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[781].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[781].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[781].bump_multiplicity(__i); } let __ret: [G; OUT_781] = unsafe { *(record.function_queries[781].output_at(__i).as_ptr() as *const [G; OUT_781]) }; __ret }, _ => aiur_fn_781(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_786] = { let __args: [G; IN_786] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__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];
@@ -65821,8 +66109,8 @@ fn aiur_fn_781(
         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_781] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
-        record.function_queries[781].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_786] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27];
+        record.function_queries[786].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65832,15 +66120,15 @@ fn aiur_fn_781(
   })
 }
 
-const INPUT_SIZE_782: usize = 9;
-const IN_782: usize = 9;
-const OUT_782: usize = 34;
-fn aiur_fn_782(
-  inp: [G; IN_782],
+const INPUT_SIZE_787: usize = 9;
+const IN_787: usize = 9;
+const OUT_787: usize = 34;
+fn aiur_fn_787(
+  inp: [G; IN_787],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_782], ExecError> {
+) -> Result<[G; OUT_787], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -65894,8 +66182,8 @@ fn aiur_fn_782(
         let __v_45: G = __r_arr[0];
         match __v_45.as_canonical_u64() {
           1u64 => {
-            let __ret: [G; OUT_782] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
-            record.function_queries[782].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_787] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43];
+            record.function_queries[787].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           0u64 => {
@@ -65908,7 +66196,7 @@ fn aiur_fn_782(
             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_782] = { let __args: [G; IN_782] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[782].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[782].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[782].bump_multiplicity(__i); } let __ret: [G; OUT_782] = unsafe { *(record.function_queries[782].output_at(__i).as_ptr() as *const [G; OUT_782]) }; __ret }, _ => aiur_fn_782(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_44, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; let __hit = record.function_queries[787].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[787].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { *(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787]) }; __ret }, _ => aiur_fn_787(__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];
@@ -65943,8 +66231,8 @@ fn aiur_fn_782(
             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_782] = [__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[782].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_787] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87];
+            record.function_queries[787].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -65959,15 +66247,15 @@ fn aiur_fn_782(
   })
 }
 
-const INPUT_SIZE_783: usize = 1;
-const IN_783: usize = 1;
-const OUT_783: usize = 1;
-fn aiur_fn_783(
-  inp: [G; IN_783],
+const INPUT_SIZE_788: usize = 1;
+const IN_788: usize = 1;
+const OUT_788: usize = 1;
+fn aiur_fn_788(
+  inp: [G; IN_788],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_783], ExecError> {
+) -> Result<[G; OUT_788], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
@@ -65977,14 +66265,14 @@ fn aiur_fn_783(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_4: G = G::from_u64(1);
-        let __ret: [G; OUT_783] = [__v_4];
-        record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_788] = [__v_4];
+        record.function_queries[788].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_4: G = G::from_u64(0);
-        let __ret: [G; OUT_783] = [__v_4];
-        record.function_queries[783].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_788] = [__v_4];
+        record.function_queries[788].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -65994,15 +66282,15 @@ fn aiur_fn_783(
   })
 }
 
-const INPUT_SIZE_784: usize = 5;
-const IN_784: usize = 5;
-const OUT_784: usize = 1;
-fn aiur_fn_784(
-  inp: [G; IN_784],
+const INPUT_SIZE_789: usize = 5;
+const IN_789: usize = 5;
+const OUT_789: usize = 1;
+fn aiur_fn_789(
+  inp: [G; IN_789],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_784], ExecError> {
+) -> Result<[G; OUT_789], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66023,17 +66311,17 @@ fn aiur_fn_784(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_784] = [__v_15];
-        record.function_queries[784].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_789] = [__v_15];
+        record.function_queries[789].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
         let __v_11: G = G::from_u64(0);
-        let __r_arr: [G; OUT_784] = { let __args: [G; IN_784] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[784].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[784].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[784].bump_multiplicity(__i); } let __ret: [G; OUT_784] = unsafe { *(record.function_queries[784].output_at(__i).as_ptr() as *const [G; OUT_784]) }; __ret }, _ => aiur_fn_784(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; let __hit = record.function_queries[789].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[789].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { *(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789]) }; __ret }, _ => aiur_fn_789(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_784] = [__v_13];
-        record.function_queries[784].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_789] = [__v_13];
+        record.function_queries[789].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -66043,15 +66331,15 @@ fn aiur_fn_784(
   })
 }
 
-const INPUT_SIZE_785: usize = 2;
-const IN_785: usize = 2;
-const OUT_785: usize = 1;
-fn aiur_fn_785(
-  inp: [G; IN_785],
+const INPUT_SIZE_790: usize = 2;
+const IN_790: usize = 2;
+const OUT_790: usize = 1;
+fn aiur_fn_790(
+  inp: [G; IN_790],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_785], ExecError> {
+) -> Result<[G; OUT_790], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66060,8 +66348,8 @@ fn aiur_fn_785(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_785] = [__v_4];
-        record.function_queries[785].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_790] = [__v_4];
+        record.function_queries[790].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -66074,11 +66362,11 @@ fn aiur_fn_785(
             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_785] = { let __args: [G; IN_785] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[785].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[785].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[785].bump_multiplicity(__i); } let __ret: [G; OUT_785] = unsafe { *(record.function_queries[785].output_at(__i).as_ptr() as *const [G; OUT_785]) }; __ret }, _ => aiur_fn_785(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_785] = [__v_9];
-            record.function_queries[785].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_790] = [__v_9];
+            record.function_queries[790].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -66090,28 +66378,28 @@ fn aiur_fn_785(
   })
 }
 
-const INPUT_SIZE_786: usize = 2;
-const IN_786: usize = 2;
-const OUT_786: usize = 1;
-fn aiur_fn_786(
-  inp: [G; IN_786],
+const INPUT_SIZE_791: usize = 2;
+const IN_791: usize = 2;
+const OUT_791: usize = 1;
+fn aiur_fn_791(
+  inp: [G; IN_791],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_786], ExecError> {
+) -> Result<[G; OUT_791], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
     match __v_1.as_canonical_u64() {
       0u64 => {
-        let __ret: [G; OUT_786] = [__v_0];
-        record.function_queries[786].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_791] = [__v_0];
+        record.function_queries[791].finish(&inp[..], &__ret[..], !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_786] = { let __args: [G; IN_786] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[786].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[786].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[786].bump_multiplicity(__i); } let __ret: [G; OUT_786] = unsafe { *(record.function_queries[786].output_at(__i).as_ptr() as *const [G; OUT_786]) }; __ret }, _ => aiur_fn_786(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_3]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
         let __v_5: G = __loaded[0];
@@ -66119,8 +66407,8 @@ fn aiur_fn_786(
         let __v_7: G = __loaded[2];
         match __v_5.as_canonical_u64() {
           0u64 => {
-            let __ret: [G; OUT_786] = [__v_7];
-            record.function_queries[786].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_791] = [__v_7];
+            record.function_queries[791].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -66132,15 +66420,15 @@ fn aiur_fn_786(
   })
 }
 
-const INPUT_SIZE_787: usize = 1;
-const IN_787: usize = 1;
-const OUT_787: usize = 1;
-fn aiur_fn_787(
-  inp: [G; IN_787],
+const INPUT_SIZE_792: usize = 1;
+const IN_792: usize = 1;
+const OUT_792: usize = 1;
+fn aiur_fn_792(
+  inp: [G; IN_792],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_787], ExecError> {
+) -> Result<[G; OUT_792], 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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr };
@@ -66152,17 +66440,17 @@ fn aiur_fn_787(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_6: G = G::from_u64(0);
-        let __ret: [G; OUT_787] = [__v_6];
-        record.function_queries[787].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_792] = [__v_6];
+        record.function_queries[792].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_787] = { let __args: [G; IN_787] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[787].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[787].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[787].bump_multiplicity(__i); } let __ret: [G; OUT_787] = unsafe { *(record.function_queries[787].output_at(__i).as_ptr() as *const [G; OUT_787]) }; __ret }, _ => aiur_fn_787(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_792] = { let __args: [G; IN_792] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[792].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[792].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { *(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792]) }; __ret }, _ => aiur_fn_792(__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_787] = [__v_8];
-        record.function_queries[787].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_792] = [__v_8];
+        record.function_queries[792].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -66172,15 +66460,15 @@ fn aiur_fn_787(
   })
 }
 
-const INPUT_SIZE_788: usize = 8;
-const IN_788: usize = 8;
-const OUT_788: usize = 6;
-fn aiur_fn_788(
-  inp: [G; IN_788],
+const INPUT_SIZE_793: usize = 8;
+const IN_793: usize = 8;
+const OUT_793: usize = 6;
+fn aiur_fn_793(
+  inp: [G; IN_793],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_788], ExecError> {
+) -> Result<[G; OUT_793], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66190,7 +66478,7 @@ fn aiur_fn_788(
     let __v_5: G = inp[5];
     let __v_6: G = inp[6];
     let __v_7: G = inp[7];
-    let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; let __hit = record.function_queries[796].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[796].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { *(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796]) }; __ret }, _ => aiur_fn_796(__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];
@@ -66201,8 +66489,8 @@ fn aiur_fn_788(
       0u64 => {
         let __v_14: G = G::from_u64(0);
         let __v_15: G = G::from_u64(1);
-        let __ret: [G; OUT_788] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
-        record.function_queries[788].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_793] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13];
+        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -66212,15 +66500,15 @@ fn aiur_fn_788(
   })
 }
 
-const INPUT_SIZE_789: usize = 1;
-const IN_789: usize = 1;
-const OUT_789: usize = 1;
-fn aiur_fn_789(
-  inp: [G; IN_789],
+const INPUT_SIZE_794: usize = 1;
+const IN_794: usize = 1;
+const OUT_794: usize = 1;
+fn aiur_fn_794(
+  inp: [G; IN_794],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_789], ExecError> {
+) -> Result<[G; OUT_794], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr };
@@ -66233,17 +66521,17 @@ fn aiur_fn_789(
     match __v_1.as_canonical_u64() {
       1u64 => {
         let __v_7: G = G::from_u64(0);
-        let __ret: [G; OUT_789] = [__v_7];
-        record.function_queries[789].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_794] = [__v_7];
+        record.function_queries[794].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
-        let __r_arr: [G; OUT_789] = { let __args: [G; IN_789] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[789].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[789].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[789].bump_multiplicity(__i); } let __ret: [G; OUT_789] = unsafe { *(record.function_queries[789].output_at(__i).as_ptr() as *const [G; OUT_789]) }; __ret }, _ => aiur_fn_789(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_794] = { let __args: [G; IN_794] = [__v_6]; let __cu = unconstrained; let __hit = record.function_queries[794].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[794].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[794].bump_multiplicity(__i); } let __ret: [G; OUT_794] = unsafe { *(record.function_queries[794].output_at(__i).as_ptr() as *const [G; OUT_794]) }; __ret }, _ => aiur_fn_794(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
         let __v_8: G = G::from_u64(1);
         let __v_9: G = (__v_7 + __v_8);
-        let __ret: [G; OUT_789] = [__v_9];
-        record.function_queries[789].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_794] = [__v_9];
+        record.function_queries[794].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -66253,15 +66541,15 @@ fn aiur_fn_789(
   })
 }
 
-const INPUT_SIZE_790: usize = 2;
-const IN_790: usize = 2;
-const OUT_790: usize = 1;
-fn aiur_fn_790(
-  inp: [G; IN_790],
+const INPUT_SIZE_795: usize = 2;
+const IN_795: usize = 2;
+const OUT_795: usize = 1;
+fn aiur_fn_795(
+  inp: [G; IN_795],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_790], ExecError> {
+) -> Result<[G; OUT_795], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66271,17 +66559,17 @@ fn aiur_fn_790(
     let __v_4: G = __loaded[2];
     match __v_2.as_canonical_u64() {
       1u64 => {
-        let __ret: [G; OUT_790] = [__v_1];
-        record.function_queries[790].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_795] = [__v_1];
+        record.function_queries[795].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __r_arr: [G; OUT_790] = { let __args: [G; IN_790] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[790].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[790].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[790].bump_multiplicity(__i); } let __ret: [G; OUT_790] = unsafe { *(record.function_queries[790].output_at(__i).as_ptr() as *const [G; OUT_790]) }; __ret }, _ => aiur_fn_790(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_795] = { let __args: [G; IN_795] = [__v_4, __v_6]; let __cu = unconstrained; let __hit = record.function_queries[795].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[795].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[795].bump_multiplicity(__i); } let __ret: [G; OUT_795] = unsafe { *(record.function_queries[795].output_at(__i).as_ptr() as *const [G; OUT_795]) }; __ret }, _ => aiur_fn_795(__args, record, io_buffer, __cu)? } };
         let __v_7: G = __r_arr[0];
-        let __ret: [G; OUT_790] = [__v_7];
-        record.function_queries[790].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_795] = [__v_7];
+        record.function_queries[795].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       _ => {
@@ -66291,15 +66579,15 @@ fn aiur_fn_790(
   })
 }
 
-const INPUT_SIZE_791: usize = 8;
-const IN_791: usize = 8;
-const OUT_791: usize = 6;
-fn aiur_fn_791(
-  inp: [G; IN_791],
+const INPUT_SIZE_796: usize = 8;
+const IN_796: usize = 8;
+const OUT_796: usize = 6;
+fn aiur_fn_796(
+  inp: [G; IN_796],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_791], ExecError> {
+) -> Result<[G; OUT_796], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66319,8 +66607,8 @@ fn aiur_fn_791(
         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_791] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
-        record.function_queries[791].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_796] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15];
+        record.function_queries[796].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
       0u64 => {
@@ -66341,22 +66629,22 @@ fn aiur_fn_791(
         let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result };
         match __v_20.as_canonical_u64() {
           1u64 => {
-            let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_1, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; let __hit = record.function_queries[796].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[796].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { *(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796]) }; __ret }, _ => aiur_fn_796(__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_792] = { let __args: [G; IN_792] = [__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; let __hit = record.function_queries[792].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[792].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { *(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792]) }; __ret }, _ => aiur_fn_792(__args, record, io_buffer, __cu)? } };
+            let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__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; let __hit = record.function_queries[797].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[797].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { *(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797]) }; __ret }, _ => aiur_fn_797(__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_791] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
-            record.function_queries[791].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_796] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32];
+            record.function_queries[796].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
           _ => {
@@ -66366,27 +66654,27 @@ fn aiur_fn_791(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_791] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
-                record.function_queries[791].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_796] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24];
+                record.function_queries[796].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
               _ => {
-                let __r_arr: [G; OUT_791] = { let __args: [G; IN_791] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[791].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[791].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[791].bump_multiplicity(__i); } let __ret: [G; OUT_791] = unsafe { *(record.function_queries[791].output_at(__i).as_ptr() as *const [G; OUT_791]) }; __ret }, _ => aiur_fn_791(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_796] = { let __args: [G; IN_796] = [__v_0, __v_1, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; let __hit = record.function_queries[796].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[796].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[796].bump_multiplicity(__i); } let __ret: [G; OUT_796] = unsafe { *(record.function_queries[796].output_at(__i).as_ptr() as *const [G; OUT_796]) }; __ret }, _ => aiur_fn_796(__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_792] = { let __args: [G; IN_792] = [__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; let __hit = record.function_queries[792].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[792].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[792].bump_multiplicity(__i); } let __ret: [G; OUT_792] = unsafe { *(record.function_queries[792].output_at(__i).as_ptr() as *const [G; OUT_792]) }; __ret }, _ => aiur_fn_792(__args, record, io_buffer, __cu)? } };
+                let __r_arr: [G; OUT_797] = { let __args: [G; IN_797] = [__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; let __hit = record.function_queries[797].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[797].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[797].bump_multiplicity(__i); } let __ret: [G; OUT_797] = unsafe { *(record.function_queries[797].output_at(__i).as_ptr() as *const [G; OUT_797]) }; __ret }, _ => aiur_fn_797(__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_791] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
-                record.function_queries[791].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_796] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33];
+                record.function_queries[796].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -66400,15 +66688,15 @@ fn aiur_fn_791(
   })
 }
 
-const INPUT_SIZE_792: usize = 15;
-const IN_792: usize = 15;
-const OUT_792: usize = 6;
-fn aiur_fn_792(
-  inp: [G; IN_792],
+const INPUT_SIZE_797: usize = 15;
+const IN_797: usize = 15;
+const OUT_797: usize = 6;
+fn aiur_fn_797(
+  inp: [G; IN_797],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_792], ExecError> {
+) -> Result<[G; OUT_797], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66427,38 +66715,38 @@ fn aiur_fn_792(
     let __v_14: G = inp[14];
     match __v_0.as_canonical_u64() {
       1u64 => {
-        let __r_arr: [G; OUT_793] = { let __args: [G; IN_793] = [__v_1, __v_2, __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; let __hit = record.function_queries[793].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[793].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[793].bump_multiplicity(__i); } let __ret: [G; OUT_793] = unsafe { *(record.function_queries[793].output_at(__i).as_ptr() as *const [G; OUT_793]) }; __ret }, _ => aiur_fn_793(__args, record, io_buffer, __cu)? } };
+        let __r_arr: [G; OUT_798] = { let __args: [G; IN_798] = [__v_1, __v_2, __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; let __hit = record.function_queries[798].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[798].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[798].bump_multiplicity(__i); } let __ret: [G; OUT_798] = unsafe { *(record.function_queries[798].output_at(__i).as_ptr() as *const [G; OUT_798]) }; __ret }, _ => aiur_fn_798(__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_792] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
-        record.function_queries[792].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_797] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20];
+        record.function_queries[797].finish(&inp[..], &__ret[..], !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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-        let __ret: [G; OUT_792] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
-        record.function_queries[792].finish(&inp[..], &__ret[..], !unconstrained);
+        let __ret: [G; OUT_797] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17];
+        record.function_queries[797].finish(&inp[..], &__ret[..], !unconstrained);
         return Ok(__ret);
       },
     }
   })
 }
 
-const INPUT_SIZE_793: usize = 14;
-const IN_793: usize = 14;
-const OUT_793: usize = 6;
-fn aiur_fn_793(
-  inp: [G; IN_793],
+const INPUT_SIZE_798: usize = 14;
+const IN_798: usize = 14;
+const OUT_798: usize = 6;
+fn aiur_fn_798(
+  inp: [G; IN_798],
   record: &mut QueryRecord,
   io_buffer: &mut IOBuffer,
   unconstrained: bool,
-) -> Result<[G; OUT_793], ExecError> {
+) -> Result<[G; OUT_798], ExecError> {
   stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {
     let __v_0: G = inp[0];
     let __v_1: G = inp[1];
@@ -66498,8 +66786,8 @@ fn aiur_fn_793(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_793] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
-                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_798] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28];
+                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                   _ => {
@@ -66523,8 +66811,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
@@ -66552,8 +66840,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66577,8 +66865,8 @@ fn aiur_fn_793(
                                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                    let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                     return Ok(__ret);
                                                   },
                                                   _ => {
@@ -66586,8 +66874,8 @@ fn aiur_fn_793(
                                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                    let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                    let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                     return Ok(__ret);
                                                   },
                                                 }
@@ -66597,8 +66885,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66626,8 +66914,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66635,8 +66923,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66646,8 +66934,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -66659,8 +66947,8 @@ fn aiur_fn_793(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                 }
@@ -66670,8 +66958,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -66703,8 +66991,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66728,8 +67016,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66737,8 +67025,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66748,8 +67036,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -66777,8 +67065,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66786,8 +67074,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -66797,8 +67085,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                     }
@@ -66810,8 +67098,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -66821,8 +67109,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -66852,8 +67140,8 @@ fn aiur_fn_793(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_793] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
-                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_798] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34];
+                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -66881,8 +67169,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -66906,8 +67194,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                               _ => {
@@ -66915,8 +67203,8 @@ fn aiur_fn_793(
                                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                                let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                                let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                                 return Ok(__ret);
                                               },
                                             }
@@ -66926,8 +67214,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -66955,8 +67243,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -66964,8 +67252,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -66975,8 +67263,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                     }
@@ -66988,8 +67276,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -66999,8 +67287,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -67032,8 +67320,8 @@ fn aiur_fn_793(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_793] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
-                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_798] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40];
+                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67057,8 +67345,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                           _ => {
@@ -67066,8 +67354,8 @@ fn aiur_fn_793(
                                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                            let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                            let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                             return Ok(__ret);
                                           },
                                         }
@@ -67077,8 +67365,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                     }
@@ -67106,8 +67394,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                       _ => {
@@ -67115,8 +67403,8 @@ fn aiur_fn_793(
                                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                        let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                        let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                         return Ok(__ret);
                                       },
                                     }
@@ -67126,8 +67414,8 @@ fn aiur_fn_793(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_793] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
-                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_798] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41];
+                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                 }
@@ -67139,8 +67427,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -67150,8 +67438,8 @@ fn aiur_fn_793(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -67185,8 +67473,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
@@ -67210,8 +67498,8 @@ fn aiur_fn_793(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_793] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_798] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                   _ => {
@@ -67219,8 +67507,8 @@ fn aiur_fn_793(
                                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                    let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                    let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                     return Ok(__ret);
                                   },
                                 }
@@ -67230,8 +67518,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -67259,8 +67547,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67268,8 +67556,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -67279,8 +67567,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -67292,8 +67580,8 @@ fn aiur_fn_793(
                     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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                    let __ret: [G; OUT_793] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                    record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                    let __ret: [G; OUT_798] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                    record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                     return Ok(__ret);
                   },
                 }
@@ -67303,8 +67591,8 @@ fn aiur_fn_793(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_793] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_798] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -67336,8 +67624,8 @@ fn aiur_fn_793(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_793] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
-                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_798] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28];
+                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                       _ => {
@@ -67361,8 +67649,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                               _ => {
@@ -67370,8 +67658,8 @@ fn aiur_fn_793(
                                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                                let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                                let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                                 return Ok(__ret);
                               },
                             }
@@ -67381,8 +67669,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -67410,8 +67698,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                           _ => {
@@ -67419,8 +67707,8 @@ fn aiur_fn_793(
                             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                            let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                            let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                             return Ok(__ret);
                           },
                         }
@@ -67430,8 +67718,8 @@ fn aiur_fn_793(
                         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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                        let __ret: [G; OUT_793] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
-                        record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                        let __ret: [G; OUT_798] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29];
+                        record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                         return Ok(__ret);
                       },
                     }
@@ -67443,8 +67731,8 @@ fn aiur_fn_793(
                 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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-                let __ret: [G; OUT_793] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-                record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+                let __ret: [G; OUT_798] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+                record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
                 return Ok(__ret);
               },
             }
@@ -67454,8 +67742,8 @@ fn aiur_fn_793(
             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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[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(__i) = __mq.get_index_of(&__values[..]) { if !unconstrained { __mq.bump_multiplicity(__i); } __mq.output_at(__i)[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } };
-            let __ret: [G; OUT_793] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
-            record.function_queries[793].finish(&inp[..], &__ret[..], !unconstrained);
+            let __ret: [G; OUT_798] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17];
+            record.function_queries[798].finish(&inp[..], &__ret[..], !unconstrained);
             return Ok(__ret);
           },
         }
@@ -71441,6 +71729,31 @@ pub(crate) fn execute_generated(
       let __out = aiur_fn_793(__inp, record, io_buffer, false)?;
       return Ok(__out.to_vec());
     },
+    794u64 => {
+      let __inp: [G; IN_794] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_794(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    795u64 => {
+      let __inp: [G; IN_795] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_795(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    796u64 => {
+      let __inp: [G; IN_796] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_796(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    797u64 => {
+      let __inp: [G; IN_797] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_797(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
+    798u64 => {
+      let __inp: [G; IN_798] = args.try_into().expect("input size mismatch");
+      let __out = aiur_fn_798(__inp, record, io_buffer, false)?;
+      return Ok(__out.to_vec());
+    },
     _ => {
       return Err(ExecError::InvalidFunIdx(fun_idx));
     },
diff --git a/crates/ixvm-codegen/src/aiur_multi_stark.rs b/crates/ixvm-codegen/src/aiur_multi_stark.rs
index 45192d652..8ca26c402 100644
--- a/crates/ixvm-codegen/src/aiur_multi_stark.rs
+++ b/crates/ixvm-codegen/src/aiur_multi_stark.rs
@@ -21954,29 +21954,43 @@ fn aiur_fn_231(
     if (__v_1 != __v_3) {
       return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_3.as_canonical_u64(), msg: Some("join: child claim is not CheckEnv".to_string()) });
     }
-    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_2]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__args, record, io_buffer, __cu)? } };
     let __v_4: G = __r_arr[0];
     let __v_5: G = __r_arr[1];
-    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__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 __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))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); 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];
-    let __v_12: G = G::from_u64(1);
-    let __v_13: G = G::from_u64(1);
-    if (__v_9 != __v_12) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_12.as_canonical_u64(), msg: Some("join: trailing bytes after CheckEnv claim".to_string()) });
+    let __v_6: G = G::from_u64(3);
+    if (__v_4 != __v_6) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_6.as_canonical_u64(), msg: Some("join: unsupported object format".to_string()) });
+    }
+    let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_5]; let __cu = unconstrained; let __hit = record.function_queries[77].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[77].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[77].bump_multiplicity(__i); } let __ret: [G; OUT_77] = unsafe { *(record.function_queries[77].output_at(__i).as_ptr() as *const [G; OUT_77]) }; __ret }, _ => aiur_fn_77(__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);
+    if (__v_7 != __v_9) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64(), msg: Some("join: wrong validator identity".to_string()) });
     }
-    if (__v_10 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: trailing bytes after CheckEnv claim".to_string()) });
+    let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_8]; let __cu = unconstrained; let __hit = record.function_queries[207].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[207].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[207].bump_multiplicity(__i); } let __ret: [G; OUT_207] = unsafe { *(record.function_queries[207].output_at(__i).as_ptr() as *const [G; OUT_207]) }; __ret }, _ => aiur_fn_207(__args, record, io_buffer, __cu)? } };
+    let __v_10: G = __r_arr[0];
+    let __v_11: G = __r_arr[1];
+    let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_11]; let __cu = unconstrained; let __hit = record.function_queries[230].get_index_of(&__args[..]); match __hit { Some(__i) if __cu || record.function_queries[230].mult_at(__i) != G::ZERO => { if !unconstrained { record.function_queries[230].bump_multiplicity(__i); } let __ret: [G; OUT_230] = unsafe { *(record.function_queries[230].output_at(__i).as_ptr() as *const [G; OUT_230]) }; __ret }, _ => aiur_fn_230(__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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_14.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; if __ptr_usize >= __mq.len() { return Err(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 }); } if !unconstrained { __mq.bump_multiplicity(__ptr_usize); } let (__args, _) = __mq.get_index(__ptr_usize).expect("bounds checked above"); let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr };
+    let __v_15: G = __loaded[0];
+    let __v_16: G = __loaded[1];
+    let __v_17: G = __loaded[2];
+    let __v_18: G = G::from_u64(1);
+    let __v_19: G = G::from_u64(1);
+    if (__v_15 != __v_18) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_18.as_canonical_u64(), msg: Some("join: trailing bytes after CheckEnv claim".to_string()) });
+    }
+    if (__v_16 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("join: trailing bytes after CheckEnv claim".to_string()) });
     }
-    if (__v_11 != __v_13) {
-      return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_13.as_canonical_u64(), msg: Some("join: trailing bytes after CheckEnv claim".to_string()) });
+    if (__v_17 != __v_19) {
+      return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_19.as_canonical_u64(), msg: Some("join: trailing bytes after CheckEnv claim".to_string()) });
     }
-    let __ret: [G; OUT_231] = [__v_4, __v_6, __v_7];
+    let __ret: [G; OUT_231] = [__v_10, __v_12, __v_13];
     record.function_queries[231].finish(&inp[..], &__ret[..], !unconstrained);
     return Ok(__ret);
   })
diff --git a/crates/kernel/src/ingress.rs b/crates/kernel/src/ingress.rs
index 76ddbc869..7c69562d6 100644
--- a/crates/kernel/src/ingress.rs
+++ b/crates/kernel/src/ingress.rs
@@ -1212,6 +1212,8 @@ fn ingress_expr<M: KernelMode>(
             }
           },
 
+          // Kernel ingress checks erased Lean types. Resource claims additionally
+          // require the addressed validator in `crate::resource`.
           IxonExpr::Lam(_, ty, body) => {
             bump_convert_stat!(stats, lam_nodes);
             if let ExprMetaData::EtaCallSite { wrapper_meta, .. } = node {
@@ -1297,7 +1299,7 @@ fn ingress_expr<M: KernelMode>(
             };
             stack.push(ExprFrame::LetDone {
               name: M::meta_field(name.clone()),
-              nd: *nd,
+              nd: nd.non_dep,
               mdata,
             });
             stack.push(ExprFrame::BinderPop);
diff --git a/crates/kernel/src/lib.rs b/crates/kernel/src/lib.rs
index 488c47e91..0bffb1eb6 100644
--- a/crates/kernel/src/lib.rs
+++ b/crates/kernel/src/lib.rs
@@ -161,6 +161,7 @@ pub mod primitive;
 // host-only partitioner — it uses rayon + `std::time` (gated to the same
 // non-riscv targets that supply those deps), and the guest never partitions.
 pub mod profile;
+pub mod resource;
 #[cfg(not(target_arch = "riscv64"))]
 pub mod shard;
 pub mod subst;
diff --git a/crates/kernel/src/resource.rs b/crates/kernel/src/resource.rs
new file mode 100644
index 000000000..a18d8ebe9
--- /dev/null
+++ b/crates/kernel/src/resource.rs
@@ -0,0 +1,264 @@
+//! Combined resource and erased-type validation for addressed Ixon v3.
+//! Kernel typechecking on its own makes no resource promise.
+
+use crate::anon_work::build_anon_work;
+use crate::env::KEnv;
+use crate::id::KId;
+use crate::mode::Anon;
+use crate::primitive::PrimAddrs;
+use crate::tc::TypeChecker;
+use ixon::env::Env;
+use ixon::resource::addressed::{AddressedProgram, Profile, check_resources};
+
+/// Minimal built-in profile, restricted to interfaces present in the closure.
+pub fn standard_profile(env: &Env) -> Profile {
+  let p = PrimAddrs::new();
+  let mut shareable_types: Vec<_> =
+    [p.nat.clone(), p.bool_type.clone(), p.string.clone()]
+      .into_iter()
+      .filter(|a| env.consts.contains_key(a))
+      .collect();
+  shareable_types.sort_unstable();
+  Profile {
+    nat_type: env.consts.contains_key(&p.nat).then_some(p.nat),
+    string_type: env.consts.contains_key(&p.string).then_some(p.string),
+    shareable_types,
+    ..Default::default()
+  }
+}
+
+pub fn check_literal_profile(profile: &Profile) -> Result<(), String> {
+  let p = PrimAddrs::new();
+  for (selected, actual) in
+    [(&profile.nat_type, &p.nat), (&profile.string_type, &p.string)]
+  {
+    if selected.as_ref().is_some_and(|selected| selected != actual) {
+      return Err("resource validator: literal type differs from the kernel primitive identity".into());
+    }
+  }
+  Ok(())
+}
+
+/// Validate both resources and erased types of the same canonical addressed
+/// closure. A caller advertising a resource claim must bind the returned
+/// profile address and this validator's identity to its subject.
+pub fn validate(
+  env: &Env,
+  profile: &Profile,
+) -> Result<AddressedProgram, String> {
+  check_literal_profile(profile)?;
+  let resolved = check_resources(env, profile)?;
+  let work = build_anon_work(env)?;
+  let mut kernel = KEnv::<Anon>::new();
+  for item in work {
+    let id = KId { addr: item.primary().clone(), name: () };
+    let mut checker = TypeChecker::new_with_lazy_anon(&mut kernel, env);
+    checker.check_const(&id).map_err(|error| {
+      format!(
+        "resource validator: erased typing failed at {}: {error:?}",
+        item.primary().hex()
+      )
+    })?;
+    // Retain structural declarations but keep reduction caches local to one
+    // work item, as in the existing anonymous driver.
+    kernel.clear_reduction_caches();
+  }
+  Ok(resolved)
+}
+
+pub fn check_claim(
+  env: &Env,
+  profile: &Profile,
+  claim: &ixon::proof::Claim,
+) -> Result<AddressedProgram, String> {
+  let ixon::proof::Claim::Resource { root, profile: expected_profile } = claim
+  else {
+    return Err("resource validator: claim uses a different validator".into());
+  };
+  let leaves: Vec<_> =
+    env.consts.iter().map(|entry| entry.key().clone()).collect();
+  if ixon::merkle::merkle_root_canonical(&leaves).as_ref() != Some(root) {
+    return Err("resource validator: claim subject differs from the complete constant set".into());
+  }
+  if &profile.address()? != expected_profile {
+    return Err(
+      "resource validator: claim profile differs from the supplied policy"
+        .into(),
+    );
+  }
+  validate(env, profile)
+}
+
+pub fn make_claim(
+  env: &Env,
+  profile: &Profile,
+) -> Result<ixon::proof::Claim, String> {
+  let leaves: Vec<_> =
+    env.consts.iter().map(|entry| entry.key().clone()).collect();
+  let root = ixon::merkle::merkle_root_canonical(&leaves)
+    .ok_or("resource validator: empty claim subject")?;
+  let claim =
+    ixon::proof::Claim::Resource { root, profile: profile.address()? };
+  check_claim(env, profile, &claim)?;
+  Ok(claim)
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use ix_common::address::Address;
+  use ix_common::env::DefinitionSafety;
+  use ixon::constant::{
+    Constant, ConstantInfo, Constructor, DefKind, Definition, Inductive,
+    MutConst, ctor_proj_constant, indc_proj_constant,
+  };
+  use ixon::contract::{BinderContract, ValueContract};
+  use ixon::expr::{Expr, Uses};
+  use ixon::univ::Univ;
+
+  fn store(env: &Env, c: Constant) -> Address {
+    let a = c.commit().0;
+    env.store_const(a.clone(), c);
+    a
+  }
+
+  #[test]
+  fn cross_language_consumer_handoff() {
+    let profile = Profile::from_bytes(include_bytes!(
+      "../../../Tests/Fixtures/ixon-v3/handoff/profile.bin"
+    ))
+    .unwrap();
+    let claim = ixon::proof::Claim::from_bytes(include_bytes!(
+      "../../../Tests/Fixtures/ixon-v3/handoff/accepted.claim"
+    ))
+    .unwrap();
+    let accepted = Env::get(
+      &mut include_bytes!(
+        "../../../Tests/Fixtures/ixon-v3/handoff/accepted.ixe"
+      )
+      .as_slice(),
+    )
+    .unwrap();
+    let rejected = Env::get(
+      &mut include_bytes!(
+        "../../../Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe"
+      )
+      .as_slice(),
+    )
+    .unwrap();
+    check_claim(&accepted, &profile, &claim).unwrap();
+    assert!(check_claim(&rejected, &profile, &claim).is_err());
+    assert!(validate(&rejected, &profile).is_err());
+    // The counterexample is well typed after erasure; its rejection is
+    // specifically a resource obligation, not a wire or Lean typing failure.
+    let mut kernel = KEnv::<Anon>::new();
+    for item in build_anon_work(&rejected).unwrap() {
+      let id = KId { addr: item.primary().clone(), name: () };
+      TypeChecker::new_with_lazy_anon(&mut kernel, &rejected)
+        .check_const(&id)
+        .unwrap();
+    }
+  }
+
+  fn base() -> (Env, Address) {
+    let env = Env::new();
+    let block = store(
+      &env,
+      Constant::with_tables(
+        ConstantInfo::Muts(vec![MutConst::Indc(Inductive {
+          is_unsafe: false,
+          lvls: 0,
+          params: 0,
+          indices: 0,
+          typ: Expr::sort(0),
+          ctors: vec![Constructor {
+            is_unsafe: false,
+            lvls: 0,
+            cidx: 0,
+            params: 0,
+            fields: 0,
+            typ: Expr::rec(0, vec![]),
+          }],
+        })]),
+        vec![],
+        vec![],
+        vec![Univ::zero()],
+      ),
+    );
+    let typ = store(&env, indc_proj_constant(0, block.clone()));
+    store(&env, ctor_proj_constant(0, 0, block));
+    (env, typ)
+  }
+  #[test]
+  fn combines_independent_resource_and_type_checks() {
+    let (env, typ) = base();
+    let c = BinderContract {
+      uses: Uses::Linear,
+      value: ValueContract::local_shared(),
+    };
+    store(
+      &env,
+      Constant::with_tables(
+        ConstantInfo::Defn(Definition {
+          kind: DefKind::Definition,
+          safety: DefinitionSafety::Safe,
+          lvls: 0,
+          typ: Expr::all_contract(
+            c,
+            ValueContract::local_shared(),
+            Expr::reference(0, vec![]),
+            Expr::reference(0, vec![]),
+          ),
+          value: Expr::lam_contract(
+            c,
+            Expr::reference(0, vec![]),
+            Expr::var(0),
+          ),
+        }),
+        vec![],
+        vec![typ.clone()],
+        vec![],
+      ),
+    );
+    validate(&env, &Profile::default()).unwrap();
+    let claim = make_claim(&env, &Profile::default()).unwrap();
+    assert!(check_claim(&env, &Profile::default(), &claim).is_ok());
+    let mut changed_profile = Profile::default();
+    changed_profile.limits.steps += 1;
+    assert!(check_claim(&env, &changed_profile, &claim).is_err());
+    assert!(
+      check_claim(
+        &env,
+        &Profile::default(),
+        &ixon::proof::Claim::CheckEnv {
+          root: Address::hash(b"subject"),
+          assumptions: None
+        }
+      )
+      .is_err()
+    );
+    assert!(
+      validate(&env, &Profile { nat_type: Some(typ), ..Default::default() })
+        .is_err()
+    );
+    let malformed = env.clone();
+    store(
+      &malformed,
+      Constant::with_tables(
+        ConstantInfo::Defn(Definition {
+          kind: DefKind::Definition,
+          safety: DefinitionSafety::Safe,
+          lvls: 0,
+          typ: Expr::sort(0),
+          value: Expr::var(0),
+        }),
+        vec![],
+        vec![],
+        vec![Univ::zero()],
+      ),
+    );
+    // This ordinary component has no resource annotation. It still must typecheck.
+    assert!(check_resources(&malformed, &Profile::default()).is_ok());
+    assert!(validate(&malformed, &Profile::default()).is_err());
+  }
+}
diff --git a/docs/Ixon-v3.md b/docs/Ixon-v3.md
new file mode 100644
index 000000000..928b1a9a9
--- /dev/null
+++ b/docs/Ixon-v3.md
@@ -0,0 +1,230 @@
+# Ixon v3: usage, ownership, and relative locality
+
+This specification describes the implemented Ixon v3 format and the admitted
+Ix source fragment. Relative locality replaces explicit lifetime parameters.
+The format is incompatible with v2; all typed addresses and primitive pins
+must be regenerated.
+
+See the [text format](ixon-text-v3.md) and the
+[resource checker](resource-checking.md) for supported behavior and checking
+limits, and the [consumer handoff](compilatrix-ixon-v3.md) for migration fixtures.
+Native resource claims are implemented. IxVM checks erased Lean typing and
+explicitly rejects resource-proof requests. The [verification record](ixon-v3-verification.md)
+lists the executed gates and formal trust boundary.
+
+## 1. Independent contracts
+
+Three properties are tracked independently:
+
+| Property | Choices | Meaning |
+| --- | --- | --- |
+| Usage | `0`, `1`, `&`, unmarked | Zero, exactly one, at most one, or any number of computational consumptions |
+| Ownership | `!`, unmarked | Unique ownership or shared access |
+| Locality | `~`, unmarked | Confined to an implicit scope or unrestricted escape |
+
+`~!` combines local scope with unique ownership. Neither `!` nor `~` changes
+the usage annotation. Every combination is representable. An implicit or
+instance binder is not erased merely because it is implicit. Native Lean
+`@&` remains a compiler hint, separate from every checked contract here.
+
+```text
+ValueContract  = { owned : unique | shared, locality : unrestricted | local }
+BinderContract = { uses : erased | linear | affine | many, value : ValueContract }
+LetContract    = { nonDep : Bool, kind : value | borrowShared, binder : BinderContract }
+```
+
+Defaults are explicit: many uses, shared ownership, unrestricted locality.
+Each forall records its input binder contract and its result value contract.
+This includes every intermediate arrow of a curried function. A final unique
+result does not imply unique intermediate closures. Lambda input contracts
+must agree with the corresponding forall.
+
+Exported defaults have these fixed meanings. Future inference may infer
+omitted contracts within an implementation, but must preserve explicit
+annotations and check the published interface. Inference cannot silently
+strengthen or weaken an imported contract.
+
+### Quantities
+
+The usage domain approximates sets of natural-number consumptions:
+`0 = {0}`, `1 = {1}`, `& = {0,1}`, `many = Nat`.
+
+Sequential demands add: zero is neutral, and two nonzero demands yield many.
+Invocation scales demand: zero absorbs, one is neutral, affine times affine
+is affine, and all other nonzero products are many. Alternatives join: equal
+zero or one stays unchanged, any many yields many, and other joins are affine.
+A declaration accepts an inferred demand only if it includes every possibility.
+In particular, exactly one rejects both zero and affine demand.
+
+Type formation and erased computation have zero runtime demand. A shared
+borrow does not consume its owner; uses of the view count against the view's
+quantity. A linear owner must still be transferred, returned, or consumed
+exactly once after its temporary loans. Closure invocation scales the demands
+on captured resources. An affine capture cannot be hidden in a closure that
+is callable arbitrarily often.
+
+## 2. Relative locality
+
+There are no lifetime names, lifetime arguments, declaration region lists,
+outlives clauses, or region abstraction/application in the semantic format.
+`App`, `Ref`, and `Recur` carry their ordinary data. Local contracts work on
+function values as well as directly referenced declarations.
+
+The checker maintains implicit scopes and the origins of values. These are
+analysis state, not externally bound lifetime variables. Function bodies and
+scoped lets establish the relevant containment boundaries. A value may carry
+several local origins through a closure, aggregate, or branch join; erasing
+their names does not allow the checker to forget a shorter-lived origin.
+
+For a function arrow, both input and result locality are relative to the
+caller's surrounding scope. Inside the function, local inputs are known to
+come from outside the function's scope:
+
+- A local input and unrestricted result prohibit retaining that input in the
+  result or in escaping storage.
+- A local input and local result allow the result to retain that input, with
+  the caller's scope restriction preserved.
+- A value confined to a scope created inside the function cannot escape that
+  scope merely because the arrow's result is marked local.
+
+An unmarked value may be used locally by forgetting its escape permission.
+A local value cannot be promoted to unrestricted merely because its immediate
+type is unchanged. The initial checked fragment has no automatic mode crossing
+for abstract resources or hidden representations.
+
+Locality applies through reachable retained data. A closure that retains a
+local value inherits its restriction. A local function argument's own contract
+and the contract on that callback's inputs are distinct: one governs storing
+the callback, and the other governs what the callback may retain from a call.
+Partial applications preserve the contracts of every remaining arrow and all
+restrictions of the captures they create.
+
+Locality is an escape contract, not a promise of stack allocation. A backend
+may choose an allocation strategy compatible with the checked contract.
+
+## 3. Ownership and scoped shared borrowing
+
+Unique input requires exclusive ownership on entry. Unique transfer consumes
+the original binding's availability. Many usage never permits two transfers
+of that same availability. Passing unique storage to shared escaping access
+permanently relinquishes exclusivity.
+
+`~!` is a uniquely owned value with a scope restriction. It is not a shared
+view that has acquired uniqueness. Shared borrowing cannot manufacture `!`.
+
+An owner is a particular binding and, where supported, a checked projection
+path. Distinct owners can belong to the same implicit scope. The initial
+projected-loan rule suspends the whole owner; field splitting requires its
+own checked rule.
+
+A let with `kind = borrowShared` interprets its initializer as an owner place:
+
+```text
+let[borrowShared, view contract] view : viewType := ownerPlace in body
+```
+
+The initializer must resolve, including through sharing, to a variable or a
+chain of checked projections from a variable. Its type must match the view's
+type. The view contract must be shared and local. The body's lexical scope
+is the loan boundary. The view retains restrictions inherited from its root
+owner and any parent view. Shared reborrows may coexist but cannot outlive
+their parent or root owner.
+
+Unique access to the root owner is suspended while a relevant loan exists.
+Scope exit checks the result, captures, aggregates, and supported stores before
+ending that scope's loans. Unique access returns only when the original owner
+is still live, was unique, and has not acquired a permanent alias. Ending a
+scope cannot restore a moved or permanently shared owner.
+
+Ordinary lets retain ordinary transfer/aliasing semantics. Locality annotation
+alone does not mark the point at which a temporary shared loan was created.
+The frontend emits the explicit borrow-let kind for temporary loans. A direct
+call that needs such a loan is elaborated with a scope covering all uses of
+its local result, rather than restoring uniqueness immediately after the call.
+
+Branch joins retain all possible use states, scope restrictions, and owner
+origins. Unique access is available after a join only if it is available on
+every incoming path. Recursive calls use checked contracts; recursive capture
+and resource summaries require a finite conservative fixed point. Unknown
+behavior must not be interpreted as no capture or no loan.
+
+Opaque/external contracts are semantic interface assumptions bound into the
+addressed interface or an admitted primitive identity and checker profile.
+Ordinary typechecking and native calling-convention hints do not certify them.
+
+## 4. Representation and canonical wire layout
+
+The binary environment version is **3** and the typed-constant protocol
+identifier is **`ixon-v3`**. Constants remain BLAKE3-addressed canonical bytes;
+the surrounding catalog/artifact protocol binds the format. Blob addresses
+remain BLAKE3 of raw bytes. No v2 fallback or mixed-version typed environment
+is admitted.
+
+The original twelve expression variants remain. Lambda and forall payloads
+carry complete contracts. The let payload carries `LetContract`. Declaration
+records keep their ordinary headers, including their universe-parameter count;
+there is no added lifetime list on any declaration or mutual member.
+
+Contract codes are:
+
+| Field | Encoding |
+| --- | --- |
+| Usage | `0` erased, `1` linear, `2` affine, `3` many |
+| Ownership | `0` unique, `1` shared |
+| Locality | `0` unrestricted, `1` local |
+| Value contract | ownership in bit 0, locality in bit 1; higher bits zero |
+| Binder contract | usage in bits 0–1, value contract in bits 2–3; higher bits zero |
+| Forall contract | binder contract in bits 0–3, result value contract in bits 4–5; higher bits zero |
+
+The four value codes are `0 = !`, `1 = unmarked`, `2 = ~!`, `3 = ~`.
+Lambda binders require one contract byte and forall binders require one
+contract byte. Application, lambda, and forall use their original maximal
+ordinary telescopes, with no term/region packet discriminants.
+
+Let uses its existing Tag4 category `0xA`. The size encodes the non-dependent
+flag in bit 0 and `borrowShared` in bit 1. Sizes above 3 are invalid. The
+payload is one binder-contract byte followed by type, initializer, and body
+expressions, in that order. Ordinary let sizes remain 0 or 1; shared-borrow
+sizes are 2 or 3. Borrowing introduces no new expression constructor or tag.
+
+All counts and indices use the shortest existing unsigned encodings. Readers
+reject nonminimal tags, reserved mode bits, invalid enum/Boolean flags, empty
+or nonmaximal telescopes, impossible counts, truncation, and trailing bytes
+at a whole-object boundary. Native readers bound count-based preallocation by
+the remaining byte budget. IxVM parses counted lists incrementally and rejects
+exhausted input through strict byte reads, without a preliminary byte traversal.
+Readers do not normalize adversarial bytes into other addresses.
+
+Source annotations, semantic contracts, canonical bytes, structural sharing
+hashes, equality, and cache keys must all distinguish the four value modes,
+four quantities, independent arrow results, and two let kinds.
+
+## 5. Admission, transport, and verification
+
+Wire validation establishes representation. Scope/type validation establishes
+term scope, types, and permitted owner-place shapes. Resource validation
+establishes usage, uniqueness, locality, captures, loans, and escape for the
+admitted fragment. Every advertised claim must state the validation it binds.
+
+Source elaboration resolves occurrence contracts before canonicalization or
+sharing. Caches must include those effective contracts and the relevant
+context, or use an expression representation that contains them. Imported and
+opaque interfaces follow the same contract path as local declarations.
+
+Open shared expressions are checked in each use's binding/scope context;
+context-free memoization is not a scope or resource-validity proof. Unsupported
+annotated transformations fail before artifact emission. Kernel erasure of a
+borrow let is its ordinary let; erasure follows the checked resource boundary
+whenever that boundary advertises resource validity.
+
+The Lean, Rust, and IxVM codecs, FFI layouts, text syntax, source frontend,
+decompiler, sharing, consumers, catalogs, and claims must agree on the format.
+The smaller schema does not remove the obligation to transport contracts or
+to bind the validator, configuration, and primitive assumptions in proofs.
+
+Verification must connect quantitative soundness, codec inverses, ordinary
+erasure, and scope/loan invariants to the executable definitions. No new axioms
+or `sorry` placeholders are permitted. Negative tests must cover hidden
+captures, closure/aggregate escape, repeated unique transfer, stale or aliased
+owner restoration, branch/recursion paths, malformed bytes, and imported
+contract mismatches, alongside accepted nontrivial higher-order examples.
diff --git a/docs/Ixon.md b/docs/Ixon.md
index c7877b9eb..8d95a618c 100644
--- a/docs/Ixon.md
+++ b/docs/Ixon.md
@@ -242,9 +242,9 @@ pub enum Expr {
     Str(u64),                               // String literal (refs index to blob)
     Nat(u64),                               // Natural literal (refs index to blob)
     App(Arc<Expr>, Arc<Expr>),              // Application
-    Lam(Uses, Arc<Expr>, Arc<Expr>),        // Lambda (usage, type, body)
-    All(Uses, Owned, Arc<Expr>, Arc<Expr>), // Forall/Pi (usage, ownership, type, body)
-    Let(bool, Arc<Expr>, Arc<Expr>, Arc<Expr>), // Let (non_dep, type, value, body)
+    Lam(BinderContract, Arc<Expr>, Arc<Expr>), // Lambda (input contract, type, body)
+    All(BinderContract, ValueContract, Arc<Expr>, Arc<Expr>), // Forall/Pi
+    Let(LetContract, Arc<Expr>, Arc<Expr>, Arc<Expr>), // Let/borrow (contract, type, value, body)
     Share(u64),                             // Reference to sharing vector
 }
 ```
@@ -253,10 +253,15 @@ pub enum Expr {
 
 1. **No names**: Binders have no names—they use de Bruijn indices. Names are stored in metadata.
 
-2. **V2 binder modes**: Lambdas and foralls carry `Uses`
-   (`erased`, `linear`, `affine`, or `many`); foralls also carry `Owned`
-   (`unique` or `shared`). Implicit/explicit binder info remains metadata.
-   Ordinary Lean compilation emits `many`/`shared`.
+2. **Independent v3 contracts**: `BinderContract { uses, value }` separates
+   quantity (`erased`, `linear`, `affine`, `many`) from the
+   `ValueContract { owned, locality }` axes. Both bound and returned values
+   can be unique/shared and local/unrestricted. Foralls carry an independent
+   result contract. `LetContract { nonDep, kind, binder }` distinguishes
+   ordinary binding from a scoped shared borrow. Ordinary Lean compilation
+   uses many/shared/unrestricted inputs and shared/unrestricted results.
+   Names and implicit/explicit binder information remain metadata.
+   See [the v3 specification](Ixon-v3.md) for the resource semantics.
 
 3. **Indirection tables**: `Ref`, `Str`, `Nat` store indices into the constant's `refs` table, not raw addresses. `Sort` stores an index into the `univs` table.
 
@@ -274,9 +279,9 @@ pub enum Expr {
 | 0x5 | Str | Refs index | None |
 | 0x6 | Nat | Refs index | None |
 | 0x7 | App | App count | Function + args (telescoped) |
-| 0x8 | Lam | Binder count | `(Uses byte + type)` per binder + body |
-| 0x9 | All | Binder count | `(Uses/Owned byte + type)` per binder + body |
-| 0xA | Let | 0=dep, 1=non_dep | Type + value + body |
+| 0x8 | Lam | Binder count | `(input-contract byte + type)` per binder + body |
+| 0x9 | All | Binder count | `(input/result-contract byte + type)` per binder + body |
+| 0xA | Let | Non-dependent flag in bit 0; borrow flag in bit 1 | Binder-contract byte + type + value + body |
 | 0xB | Share | Share index | None |
 
 ### Telescope Compression
@@ -292,14 +297,21 @@ Tag4 { flag: 0x7, size: 3 }  // 3 applications
 **Lambdas**: `Lam(t1, Lam(t2, Lam(t3, body)))` becomes:
 ```
 Tag4 { flag: 0x8, size: 3 }  // 3 binders
-+ uses1 + t1 + uses2 + t2 + uses3 + t3 + body
++ contract1 + t1 + contract2 + t2 + contract3 + t3 + body
 ```
 
-Lambda mode bytes are `Uses` in bits 0–1. Forall mode bytes use bits 0–1
-for `Uses` and bit 2 for `Owned`; other bits are invalid. Foralls otherwise
-use the same telescope layout with flag 0x9. Readers require nonempty,
-maximal telescopes and reject a nested constructor of the same kind as the
-decoded base/body.
+Value codes are `0 = !`, `1 = unmarked`, `2 = ~!`, `3 = ~`.
+The binder byte is `uses | (value << 2)`, with quantity codes
+`0 = erased`, `1 = linear`, `2 = affine`, `3 = many`.
+Foralls store `input | (result << 4)`. Bits above bit 3 on lambdas
+or bit 5 on foralls are invalid. The ordinary lambda byte is `0x07`;
+the ordinary forall byte is `0x17`.
+
+Foralls use the same telescope layout with flag 0x9. Readers require
+nonempty, maximal telescopes and reject a nested constructor of the same
+kind as the decoded base/body. Let sizes above 3 and nonminimal integer
+encodings are invalid. A syntactically valid borrow record is still subject
+to the separate owner-place and resource checks.
 
 ### Expression Examples
 
@@ -319,9 +331,9 @@ Tag4 { flag: 0x2, size: 2 }
 + Tag0(1)  // second univ index
 Bytes: 0x22 0x00 0x00 0x01
 
-Expr::Lam(Many, type_expr, Lam(Affine, type_expr2, body))
+Expr::Lam(many_shared, type_expr, Lam(affine_shared, type_expr2, body))
 Tag4 { flag: 0x8, size: 2 }
-+ 0x03 + type_expr + 0x02 + type_expr2 + body
++ 0x07 + type_expr + 0x06 + type_expr2 + body
 
 Expr::Share(5)  // Reference to sharing[5]
 Tag4 { flag: 0xB, size: 5 }
@@ -550,13 +562,10 @@ An inductive type definition with its constructors.
 
 ```rust
 pub struct Inductive {
-    pub recr: bool,        // Has recursive occurrences
-    pub refl: bool,        // Is reflexive
     pub is_unsafe: bool,
     pub lvls: u64,         // Universe parameter count
     pub params: u64,       // Number of parameters
     pub indices: u64,      // Number of indices
-    pub nested: u64,       // Nested inductive depth
     pub typ: Arc<Expr>,    // Type expression
     pub ctors: Vec<Constructor>,
 }
@@ -564,11 +573,10 @@ pub struct Inductive {
 
 **Serialization**:
 ```
-Packed bools (1 byte): bit 0 = recr, bit 1 = refl, bit 2 = is_unsafe
+is_unsafe (1 byte: 0 or 1)
 + lvls (Tag0)
 + params (Tag0)
 + indices (Tag0)
-+ nested (Tag0)
 + typ (Expr)
 + ctors.len (Tag0)
 + [Constructor]*
@@ -607,7 +615,7 @@ The sharing system deduplicates common subexpressions within a constant.
 
 ### How It Works
 
-1. **Merkle hashing**: Every subexpression is assigned a structural hash using blake3
+1. **Merkle hashing**: Every subexpression is assigned a structural hash using blake3. Its preimage is the canonical isolated-node scalar/contract header followed by one fixed 32-byte hash per child, in structural order. Input, result, locality, let-kind, and dependency fields all participate.
 2. **Usage counting**: Count how many times each unique subexpression appears
 3. **Profitability analysis**: Decide which subexpressions to share based on size savings
 4. **Rewriting**: Replace selected subexpressions with `Share(idx)` references
@@ -868,9 +876,9 @@ The .ixe layout is a `Tag4(0xE, VERSION)` header byte followed by a
 32-byte canonical merkle root, the bundle header fields, and then 6
 sections (hot data first, metadata last).
 
-The format has the stable identifier `ixon-v2`. The Tag4 size field is the
-numeric **format version** (`Env::VERSION`, currently `2`, so the first byte
-of a v2 file is `0xE2`). Any change
+The format has the stable identifier `ixon-v3`. The Tag4 size field is the
+numeric **format version** (`Env::VERSION`, currently `3`, so the first byte
+of a v3 file is `0xE3`). Any change
 to serialized bytes bumps the version; every reader
 (`read_env_header` on the Rust side, `Ixon.getEnv` /
 `getEnvVerifiedLazy` on the Lean side) rejects a mismatch with an
@@ -880,7 +888,7 @@ artifacts. Versions 0–7 cost zero additional bytes (inline Tag4
 size); later versions cost a trimmed varint.
 
 ```
-Header:      Tag4 { flag: 0xE, size: VERSION }  -- 0xE2 for version 2
+Header:      Tag4 { flag: 0xE, size: VERSION }  -- 0xE3 for version 3
 Root:        32 bytes                     -- canonical merkle root over
                                             consts.keys(); for empty
                                             const sets this is the
@@ -1146,8 +1154,10 @@ fixed-width little-endian like `.ixes`; source of truth
 
 ```
 magic    b"IXC\0\0\0\0\0"            (8)
-version  u32 = 1
+version  u32 = 2
 flags    u32                          # bit0: storage profile (0 = fat, 1 = chunked)
+object_format     u8 = 3              # ixon-v3
+validator         u8 = 1              # erased-lean-v1 catalog claims
 members_root      32 bytes
 content_root      32 bytes
 member_count      u32
@@ -1187,16 +1197,22 @@ source of truth). The `Catalog` claim (below) binds both roots.
 
 Envs, commitments, the AssumptionTree data type, and all claims share
 Tag4 flag 0xE. Proofs (opaque ZK bytes) share Tag4 flag 0xF. Sizes
-0..=7 fit in single-byte tags; with variants 0–7 under 0xE all taken,
-the Catalog claim (variant 8) is the first — and so far only —
-multi-byte tag in this space: it encodes as `0xE8 0x08` (large bit
-set, one size byte).
+0..=7 fit in single-byte tags. Catalog (variant 8) and Resource (variant 9)
+use `0xE8 0x08` and `0xE8 0x09`. Environment tags are interpreted in
+the `.ixe` context: the v3 environment header is `0xE3`, independently of
+the Eval claim tag. The enclosing protocol must identify the object kind.
+
+Every claim and proof payload starts with two bytes immediately after Tag4:
+object format `3`, then validator `0` (structural-v1), `1` (erased-lean-v1),
+or `2` (resource-v1). Readers require the validator assigned to that variant.
+Whole-object readers reject trailing bytes and earlier unscoped encodings.
+These bytes are included in the claim digest and proof statement.
 
 ### Tag4 0xE Variant Layout (Env + Comm + AssumptionTree + Claims)
 
 | Size | Byte | Type | Payload |
 |------|------|------|---------|
-| 0 | `0xE0` | Environment | 32-byte merkle root + main/assumptions + 6 sections |
+| 3 (format) | `0xE3` | Environment (`.ixe` context) | 32-byte merkle root + main/assumptions + 6 sections |
 | 1 | `0xE1` | Commitment | 2 addr: secret, payload |
 | 2 | `0xE2` | AssumptionTree | recursive merkle-tree body (see below) |
 | 3 | `0xE3` | Eval claim | 2 addr (input, output) + opt assumptions |
@@ -1205,6 +1221,11 @@ set, one size byte).
 | 6 | `0xE6` | Reveal claim | 1 addr (comm) + RevealConstantInfo |
 | 7 | `0xE7` | Contains claim | 2 addr (tree, const) |
 | 8 | `0xE8 0x08` | Catalog claim | 2 addr (members root, content root) + opt assumptions |
+| 9 | `0xE8 0x09` | Resource claim | 2 addr (complete env root, resource profile) |
+
+The claim payloads in this table follow the two scope bytes. Reveal and
+Contains require validator `0`; Eval, Check, CheckEnv, and Catalog require
+validator `1`; Resource requires validator `2`.
 
 `opt assumptions` encoding: 1 byte `0x00` for `None`, or `0x01` followed
 by 32 bytes for `Some(merkle_root)`.
@@ -1228,10 +1249,14 @@ the multi-byte-tag path.
 | 3 | `0xF3` | Reveal proof | claim payload + Tag0 length + opaque ZK bytes |
 | 4 | `0xF4` | Contains proof | claim payload + Tag0 length + opaque ZK bytes |
 | 5 | `0xF5` | Catalog proof | claim payload + Tag0 length + opaque ZK bytes |
+| 6 | `0xF6` | Resource proof wrapper | claim payload + Tag0 length + opaque proof bytes |
 
 Proof bytes are uniform opaque ZK proofs — witness data (e.g., merkle
 paths for Contains) is prover-side scratch consumed by the ZK circuit
-and NOT transmitted on the wire.
+and NOT transmitted on the wire. Wrapper decoding alone proves nothing.
+IxVM supports Check, CheckEnv, Reveal, and Contains; Resource is currently
+validated by the native Lean/Rust boundary and is explicitly rejected as an
+IxVM proof request. Catalog proofs compose erased CheckEnv claims.
 
 ### Claim Types
 
@@ -1255,6 +1280,8 @@ pub enum Claim {
     /// COMPOSITION of per-piece CheckEnv claims with set discharge —
     /// there is deliberately no whole-catalog interpreter arm.
     Catalog { members: Address, content: Address, assumptions: Option<Address> },
+    /// Complete closure passes resource-v1 under the committed profile.
+    Resource { root: Address, profile: Address },
 }
 ```
 
@@ -1316,6 +1343,7 @@ pub struct Proof {
 **Eval claim** (0xE3, 2 addresses + opt assumptions byte):
 ```
 E3                    -- Tag4 { flag: 0xE, size: 3 } (Eval)
+03 01                 -- object format 3, erased-lean-v1
 [32 bytes]            -- input address
 [32 bytes]            -- output address
 00                    -- assumptions = None (or 01 + [32 bytes] for Some)
@@ -1324,6 +1352,7 @@ E3                    -- Tag4 { flag: 0xE, size: 3 } (Eval)
 **Eval proof** (0xF0, claim payload + opaque ZK bytes):
 ```
 F0                    -- Tag4 { flag: 0xF, size: 0 } (Eval proof)
+03 01                 -- object format 3, erased-lean-v1
 [32 bytes]            -- input address
 [32 bytes]            -- output address
 00                    -- assumptions = None
@@ -1334,6 +1363,7 @@ F0                    -- Tag4 { flag: 0xF, size: 0 } (Eval proof)
 **Check claim** (0xE4, 1 address + opt assumptions byte):
 ```
 E4                    -- Tag4 { flag: 0xE, size: 4 } (Check)
+03 01                 -- object format 3, erased-lean-v1
 [32 bytes]            -- const address
 00                    -- assumptions = None
 ```
@@ -1341,20 +1371,22 @@ E4                    -- Tag4 { flag: 0xE, size: 4 } (Check)
 **Reveal claim** — reveal that a committed Definition has `safety = Safe`:
 ```
 E6                    -- Tag4 { flag: 0xE, size: 6 } (Reveal)
+03 00                 -- object format 3, structural-v1
 [32 bytes]            -- comm_addr
 00                    -- variant: Definition
 02                    -- mask: bit 1 (safety) [Tag0]
 01                    -- DefinitionSafety::Safe
 ```
-Total: 36 bytes.
+Total: 38 bytes.
 
 **Contains claim** (0xE7, 2 addresses):
 ```
 E7                    -- Tag4 { flag: 0xE, size: 7 } (Contains)
+03 00                 -- object format 3, structural-v1
 [32 bytes]            -- tree (merkle root)
 [32 bytes]            -- const address (asserted leaf)
 ```
-Total: 65 bytes.
+Total: 67 bytes.
 
 ---
 
@@ -1382,13 +1414,19 @@ The `compile_expr` function transforms Lean expressions:
 | `Sort(level)` | `Sort(idx)` | Level added to univs table |
 | `Const(name, levels)` | `Ref(idx, univ_idxs)` | Name resolved to address |
 | `Const(name, levels)` in mutual | `Rec(ctx_idx, univ_idxs)` | Uses mutual context |
-| `Lam(name, ty, body, info)` | `Lam(many, ty, body)` | Conservative v2 mode; name/info to metadata |
-| `ForallE(name, ty, body, info)` | `All(many, shared, ty, body)` | Conservative v2 modes; name/info to metadata |
-| `LetE(name, ty, val, body, nd)` | `Let(nd, ty, val, body)` | Name to metadata |
+| `Lam(name, ty, body, info)` | `Lam(many_shared, ty, body)` | Ordinary v3 contract; name/info to metadata |
+| `ForallE(name, ty, body, info)` | `All(many_shared, shared, ty, body)` | Ordinary v3 contracts; name/info to metadata |
+| `LetE(name, ty, val, body, nd)` | `Let({nonDep: nd, kind: value, binder: many_shared}, ty, val, body)` | Name to metadata; ordinary let contract |
 | `Proj(type, idx, val)` | `Prj(type_idx, idx, val)` | Type name resolved |
 | `Lit(Nat n)` | `Nat(idx)` | Bytes stored in blobs |
 | `Lit(Str s)` | `Str(idx)` | Bytes stored in blobs |
 
+This table describes unannotated source. The source-contract frontend resolves
+annotations before canonicalization and sharing, then transports their exact
+contracts through the reserved semantic metadata frame. Both production
+compilers validate resources and erased typing before emitting annotated
+artifacts. Unsupported transformations reject explicitly.
+
 ### Metadata Extraction
 
 During compilation, metadata is extracted into `ExprMetas`:
@@ -1416,10 +1454,14 @@ Decompilation reconstructs Lean constants from Ixon format.
 1. **Load constant** from `env.consts` by address
 2. **Initialize tables** from `sharing`, `refs`, `univs`
 3. **Load metadata** from `env.named`
-4. **Reconstruct expressions** with names and binder info from metadata
+4. **Reconstruct expressions** with committed contracts, and names/binder info from metadata
 5. **Resolve references**: `Ref(idx, _)` → lookup `refs[idx]`, get name from `addr_to_name`
 6. **Expand shares**: `Share(idx)` → inline `sharing[idx]` (or cache result)
 
+Nondefault contracts are reconstructed from semantic bytes even without names
+or optional metadata. Optional metadata cannot inject contracts or replay an
+unsupported rewrite that would erase them.
+
 ### Roundtrip Verification
 
 The `check_decompile` function verifies:
@@ -1466,15 +1508,15 @@ value: Lam("n", Const(`Nat, []),
 
 **Compile type**:
 ```
-All(Ref(0, []), Ref(0, []))
+All(many_shared, shared, Ref(0, []), Ref(0, []))
 ```
-Binary: `0x91` (All, 1 binder) + `0x20 0x00` (Ref, 0 univs, idx 0) + `0x20 0x00`
+Binary: `0x91 0x17` (All, 1 ordinary binder/result) + `0x20 0x00` (Ref, 0 univs, idx 0) + `0x20 0x00`
 
 **Compile value**:
 ```
-Lam(Ref(0, []), App(App(Ref(1, []), Var(0)), Var(0)))
+Lam(many_shared, Ref(0, []), App(App(Ref(1, []), Var(0)), Var(0)))
 ```
-Binary: `0x81` (Lam, 1 binder) + `0x20 0x00` (Ref 0) + `0x72` (App, 2 apps) + `0x20 0x01` (Ref 1) + `0x10` (Var 0) + `0x10` (Var 0)
+Binary: `0x81 0x07` (Lam, 1 ordinary binder) + `0x20 0x00` (Ref 0) + `0x72` (App, 2 apps) + `0x20 0x01` (Ref 1) + `0x10` (Var 0) + `0x10` (Var 0)
 
 **Sharing analysis**: `Var(0)` appears twice, but too small to benefit from sharing.
 
@@ -1485,8 +1527,8 @@ Constant {
     kind: Definition,
     safety: Safe,
     lvls: 0,
-    typ: All(Ref(0, []), Ref(0, [])),
-    value: Lam(Ref(0, []), App(App(Ref(1, []), Var(0)), Var(0))),
+    typ: All(many_shared, shared, Ref(0, []), Ref(0, [])),
+    value: Lam(many_shared, Ref(0, []), App(App(Ref(1, []), Var(0)), Var(0))),
   }),
   sharing: [],
   refs: [addr_of_Nat, addr_of_Nat_add],
@@ -1500,8 +1542,8 @@ Constant {
 D0                    -- Tag4 { flag: 0xD, size: 0 } (Constant, Defn variant)
 01                    -- DefKind+Safety packed: (Definition=0 << 2) | Safe=1
 00                    -- lvls = 0 (Tag0)
-91 20 00 20 00        -- type: All(Ref(0,[]), Ref(0,[]))
-81 20 00 72 20 01     -- value: Lam(Ref(0,[]), App(App(Ref(1,[])...
+91 17 20 00 20 00     -- type: All(Ref(0,[]), Ref(0,[]))
+81 07 20 00 72 20 01  -- value: Lam(Ref(0,[]), App(App(Ref(1,[])...
    10 10              --        ...Var(0)), Var(0)))
 00                    -- sharing.len = 0
 02                    -- refs.len = 2
@@ -1510,7 +1552,8 @@ D0                    -- Tag4 { flag: 0xD, size: 0 } (Constant, Defn variant)
 00                    -- univs.len = 0
 ```
 
-Total: ~69 bytes for the constant data (plus 64 bytes for addresses).
+Total: 21 bytes for the scalar/expression data and table counts, plus
+64 bytes for the two addresses: **85 bytes**.
 
 Note: The constant tag is always 1 byte (0xD0) since all non-Muts variants (0-7) fit in the 3-bit size field.
 
@@ -1582,24 +1625,21 @@ inductive Bool : Type where
 
 ### Mutual Block Structure
 
-Since `Bool` is an inductive type, it's stored in a mutual block containing:
-1. The inductive type itself (`Bool`)
-2. Its constructors (`Bool.false`, `Bool.true`)
-3. Its recursor (`Bool.rec`)
+The family block contains one inductive entry for `Bool`, including its two
+constructor records. The recursor has a separate block referring to the family.
+Constructors are nested in their inductive entry, rather than additional mutual
+members.
 
 ### Ixon Compilation
 
 **Inductive (Bool)**:
 ```rust
 Inductive {
-  recr: false,       // No recursive occurrences
-  refl: false,       // Not reflexive
   is_unsafe: false,
   lvls: 0,           // No universe parameters
   params: 0,         // No parameters
   indices: 0,        // No indices
-  nested: 0,         // Not nested
-  typ: Sort(0),      // Type : Type 0
+  typ: Sort(0),      // univs[0] = Succ(Zero), so Bool : Type
   ctors: [ctor_false, ctor_true],
 }
 ```
@@ -1633,15 +1673,14 @@ Constructor {
 The mutual block uses flag 0xC with entry count in size field:
 
 ```
-C3                    -- Tag4 { flag: 0xC, size: 3 } (Muts, 3 entries)
+C1                    -- Tag4 { flag: 0xC, size: 1 } (Muts, 1 entry)
 
 -- Entry 0: Inductive (Bool)
 01                    -- MutConst tag 1 = Indc
-00                    -- Packed bools: recr=0, refl=0, is_unsafe=0
+00                    -- is_unsafe = false
 00                    -- lvls = 0
 00                    -- params = 0
 00                    -- indices = 0
-00                    -- nested = 0
 00                    -- typ: Sort(0)
 02                    -- ctors.len = 2
   -- ctor_false
@@ -1659,17 +1698,11 @@ C3                    -- Tag4 { flag: 0xC, size: 3 } (Muts, 3 entries)
   00                  -- fields = 0
   30 00               -- typ: Rec(0, []) - mutual reference to Bool at index 0
 
--- Entry 1: Recursor (Bool.rec) - omitted for brevity
-02 ...
-
--- Entry 2: Definition for Bool.casesOn or similar - if present
-...
-
 -- Shared tables
 00                    -- sharing.len = 0
 00                    -- refs.len = 0 (no external references needed)
 01                    -- univs.len = 1
-00                    -- univs[0] = Zero
+01 00                 -- univs[0] = Succ(Zero)
 ```
 
 ### Projections
@@ -1678,7 +1711,7 @@ Individual constants are stored as projections into this block:
 - `Bool` → `IPrj { idx: 0, block: block_addr }`
 - `Bool.false` → `CPrj { idx: 0, cidx: 0, block: block_addr }`
 - `Bool.true` → `CPrj { idx: 0, cidx: 1, block: block_addr }`
-- `Bool.rec` → `RPrj { idx: 0, block: block_addr }`
+- `Bool.rec` → `RPrj { idx: 0, block: recursor_block_addr }`
 
 ---
 
@@ -1695,7 +1728,7 @@ pub struct Comm {
 
 The commitment address is computed as:
 ```
-commitment = blake3(Tag4(0xE, 5) + secret + payload)
+commitment = blake3(Tag4(0xE, 1) + secret + payload)
 ```
 
 The payload address is the content hash of the committed constant. Two commitments to the
diff --git a/docs/compilatrix-ixon-v3.md b/docs/compilatrix-ixon-v3.md
new file mode 100644
index 000000000..79edd0bf9
--- /dev/null
+++ b/docs/compilatrix-ixon-v3.md
@@ -0,0 +1,80 @@
+# Compilatrix handoff: Ixon v3
+
+This package describes the Ix producer and its checked fragment. Compilatrix
+has not been changed or tested by this work. Consume the versioned data and
+validation interfaces below before enabling ownership or locality optimizations.
+
+## Breaking format
+
+- Environment format: **3**, protocol identity **`ixon-v3`**.
+- Twelve expression variants and the existing declaration headers remain.
+- Lambda binder contracts use four bits; forall input/result contracts use six.
+- Let Tag4 sizes encode `nonDep` in bit 0 and `borrowShared` in bit 1. A binder
+  byte precedes its type, initializer, and body.
+- Catalog manifests use version **2**, with object-format byte `3` and validator
+  byte `1` after the flags. They describe erased-typing claims.
+- Claim and proof payloads include format and validator bytes after Tag4.
+- Primitive addresses have changed. Do not reuse v2 pins or infer an object's
+  version from raw constant bytes.
+
+See the [schema](Ixon-v3.md), [wire format](Ixon.md),
+[text syntax](ixon-text-v3.md), and [source frontend](source-contracts.md).
+
+## Validation contract
+
+`Ix.Resource.validate` and Rust `ix_kernel::resource::validate` check canonical
+addressed bytes, reference closure, resource rules, and erased Lean typing.
+`makeClaim` and `checkClaim` additionally bind the complete constant-set root
+and the canonical profile address. Profile identity includes assumptions,
+shareable representations, selection behavior, literal pins, and checker limits.
+Optional metadata and cached materializations grant no semantic facts.
+
+| Interface | Status |
+| --- | --- |
+| Lean/Rust codecs, equality, hashing, sharing, FFI, text | V3 |
+| Lean/Rust source compilation | Resource-checked annotated definitions and admitted interfaces |
+| Decompilation | Reconstructs committed contracts; unsupported metadata rewrites reject |
+| Native resource admission and Resource claims | Implemented with explicit profiles |
+| IxVM codecs and structural revelation | Preserve every v3 contract field |
+| IxVM Check/CheckEnv | Erased-lean-v1; contracts do not strengthen that statement |
+| IxVM Resource proofs | Explicitly unsupported |
+| Compilatrix backend | External migration required; support not inferred from these fixtures |
+
+Annotated inductive/constructor/recursor generation and nonidentity compiler
+surgery reject before emission. The native projection fragment requires closed,
+transparent fields with many usage. See [resource checking](resource-checking.md)
+for higher-order capture, recursion, loan, and normalization limits.
+
+## Fixture package
+
+The [fixture directory](../Tests/Fixtures/ixon-v3/) contains:
+
+| File | Purpose |
+| --- | --- |
+| `expressions.txt` | Independently authored canonical expression bytes and addresses |
+| `text.tsv` | All binder/arrow modes and both let kinds |
+| `resource.tsv` | Accepted and rejected resource programs |
+| `addressed.tsv` | Addressed declarations and a canonical profile |
+| `claims.tsv` | Claim bytes and BLAKE3 digests for every variant |
+| `primitives.tsv` | Regenerated v3 primitive identities |
+| `handoff/accepted.ixe` | Complete anonymous closure with a linear local identity |
+| `handoff/rejected-local-escape.ixe` | Type-correct closure whose local input escapes |
+| `handoff/profile.bin` | Canonical resource profile with no external assumptions |
+| `handoff/accepted.claim` | Native resource claim for the accepted closure |
+| `handoff/manifest.json` | Exact file hashes and subject/profile/claim identities |
+
+Both binary environments must decode and pass erased typing. Resource admission
+must accept the first and reject the second. Changing any committed contract,
+subject, or profile must invalidate the associated identity. Reading the claim
+is not validation, and its bytes are not an IxVM resource proof.
+
+Run `lake exe ixon-v3-tests` from the repository root for codec, FFI, source,
+resource, decompiler, catalog, and VM checks. `--primitives` additionally checks
+the generated primitive closure at `/tmp/ixon-v3-primitives.ixe`.
+`--export-handoff` writes the deterministic handoff files under
+`/tmp/ixon-v3-handoff`; copy them into the fixture directory only after validation.
+
+The formal gates are `lake build IxCompileVerify IxTcVerify Ix.Resource.Audit`.
+Resource theorems cover the executed quantitative and state-transition
+invariants. They do not constitute a verified allocation backend or a proof of
+the entire resource checker against a machine operational semantics.
diff --git a/docs/ixon-text-v3.md b/docs/ixon-text-v3.md
new file mode 100644
index 000000000..6d16090b1
--- /dev/null
+++ b/docs/ixon-text-v3.md
@@ -0,0 +1,106 @@
+# Ixon v3 text syntax
+
+The Lean and Rust parsers use grammar version **3**. Whole files start with
+`ixon 3`; missing headers and explicit older versions are rejected.
+Canonical printing includes the header, a blank line between sections,
+and a final newline. Standalone term parsing uses the current grammar
+without a file header.
+
+```text
+ixon 3
+
+def keep : (~!1 x : A) → ~! A := fun (~!1 x : A) => x
+
+⊢ keep : (~!1 x : A) → ~! A
+```
+
+## Contracts
+
+Binder prefixes use three independent axes:
+
+| Axis | Prefixes | Default |
+| --- | --- | --- |
+| Quantity | `0`, `1`, `&` | Many |
+| Ownership | `!` | Shared |
+| Locality | `~` | Unrestricted |
+
+Prefixes are adjacent to each other and separated from the binder name
+by whitespace. Each axis occurs at most once. The parser accepts any
+order; the printer uses locality, ownership, then quantity:
+
+```text
+fun (~!1 owner : A) => owner
+fun (~& view : A) => view
+fun (0 proof : P) => value
+```
+
+A binder group applies its input contract to every name in that group.
+Bracket shapes retain the ordinary implicit/explicit information:
+
+```text
+fun {0 A : Type} (!1 x y : A) [~ instance : C] => body
+```
+
+A prefix on an unnamed instance binder is also preserved, for example
+`[~ C]`.
+
+## Arrow results
+
+The independent result contract appears immediately after the arrow.
+Results use only `!` and `~`; quantities belong to inputs.
+
+```text
+(!1 x : A) → ! B
+(~ x : A) → ~ B
+(~!1 x : A) → ~! B
+A → ~! B
+```
+
+Arrows associate to the right. In a multi-binder group followed by one
+arrow, the written result applies to the final arrow. Earlier arrows have
+the shared, unrestricted result default. Nest arrows to spell each
+intermediate result explicitly:
+
+```text
+(~!1 x : A) → ~! ((~& y : B) → ~ C)
+```
+
+The local interpretation and closure restrictions are specified in
+[Ixon v3](Ixon-v3.md).
+
+## Let and shared borrow
+
+Ordinary unannotated bindings keep the compact syntax:
+
+```text
+let x : A := value; body
+have x : A := value; body
+```
+
+A contracted let uses one explicit parenthesized binder. `have` sets the
+non-dependent flag. `borrow` sets the shared-borrow kind:
+
+```text
+let (~!1 owner : A) := value; body
+let borrow (~ view : A) := owner; body
+have borrow (~& view : A) := owner; body
+```
+
+The body is the borrow's loan boundary. Ordinary locality annotations do
+not create a temporary loan. Canonical printing starts the body on the
+next line. The word `borrow` is reserved; a name with that spelling is
+written `«borrow»`.
+
+## Validation boundary and fixtures
+
+The text AST retains input contracts, per-arrow results, and all let fields.
+Parsing and printing do not establish typing, ownership, or loan validity.
+In particular, the text grammar can represent every wire-level let
+combination; the resource checker is responsible for rejecting a borrow
+view whose contract is not shared and local.
+
+The shared [contract fixtures](../Tests/Fixtures/ixon-v3/text.tsv) cover
+all 16 lambda inputs, 64 dependent arrow input/result pairs, four
+non-dependent arrow results, and 64 let flag/contract combinations.
+Both implementations check the parsed fields and canonical text.
+Property tests generate contracts throughout nested terms and files.
diff --git a/docs/ixon-v3-verification.md b/docs/ixon-v3-verification.md
new file mode 100644
index 000000000..0af6ab9ac
--- /dev/null
+++ b/docs/ixon-v3-verification.md
@@ -0,0 +1,106 @@
+# Ixon v3 implementation and verification record
+
+Ixon v3 carries independent usage, ownership, and relative-locality contracts
+through the Ix source frontend, Lean and Rust compilers, canonical bytes,
+sharing, text syntax, FFI, and decompilation. Scoped shared borrowing uses an
+explicit let kind. Native admission checks resources and erased typing before
+an annotated production artifact is emitted.
+
+## Implemented boundary
+
+- Definitions, theorems, opaque bodies, and explicitly admitted interfaces are
+  supported. Annotated inductive/constructor/recursor generation and nonidentity
+  compiler surgery reject before emission.
+- Native Resource claims bind the complete constant-set root, object format,
+  validator, and canonical profile. The profile commits external assumptions,
+  representation rules, primitive pins, and analysis limits.
+- IxVM preserves all contract fields and proves its advertised erased-typing
+  or structural statement. Resource-proof requests reject explicitly.
+- Compilatrix migration remains external. The
+  [handoff package](compilatrix-ixon-v3.md) supplies complete accepted and
+  rejected environments, a profile, a resource claim, and exact identities.
+
+The [resource-checker specification](resource-checking.md) records the bounded
+normalization, higher-order capture, recursion, and projection fragment.
+
+## Executed gates
+
+Commands run from the repository root:
+
+| Gate | Result |
+| --- | --- |
+| `lake build IxCompileVerify IxTcVerify Ix.Resource.Audit` | Passed; exact trust manifests and local sorry-frontier audits |
+| `lake build IxTests ixon-v3-tests ix` | Passed |
+| `lake lint -- --wfail` | Passed for every target included by the CI lint driver |
+| `lake env .lake/build/bin/IxTests` | Entire primary suite passed, including recursive proof and aggregate consumers |
+| `lake env .lake/build/bin/IxTests cli` | Passed, including fresh-process source and imported contracts, anonymous output, and no-artifact rejection |
+| `lake env .lake/build/bin/IxTests --ignored validate-aux aux-gen-diff decompile-diff` | Passed production-driver parity and complete decompiler fidelity |
+| `lake env .lake/build/bin/IxTests --ignored compile-determinism` | Fixture corpus and Batteries each emitted SHA256-identical files in separate processes |
+| `lake env .lake/build/bin/IxTests --ignored ixvm` | Passed all kernel, adversarial, generated-code parity, exact FFT-cost, and shard checks |
+| `lake env .lake/build/bin/ixon-v3-tests` | Passed, including bytecode/generated-Rust/source-interpreter claim parity and proof verification |
+| `.lake/build/bin/ixon-v3-primitives` followed by `.lake/build/bin/ixon-v3-tests --primitives` | Passed; 3,634 constants and 3,540 addressed interfaces validated |
+| `.lake/build/bin/ix codegen --check` | Passed for the regenerated kernel and both recursive consumers |
+| `cargo fmt --all -- --check` | Passed |
+| `cargo clippy --release --workspace --all-targets --features ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi -- -D warnings` | Passed |
+| `cargo check --release --workspace --all-targets --features ix-ffi/parallel,ix-ffi/net,ix-ffi/test-ffi` | Passed |
+| `cargo test --release --workspace` | 1,563 passed; 14 existing ignored tests |
+| `cargo nextest run --release --profile ci --workspace` | 1,563 passed; 14 existing skipped tests |
+
+The dedicated v3 suite reports 1,844 golden-byte/rejection checks, 475 FFI and
+sharing checks, 3,639 VM checks, 458 text checks, 131 resource checks, and 18
+admission checks, plus addressed validation, compiler transport, decompilation,
+claim, catalog, primitive, source, and handoff suites. It includes all 16 binder
+contracts and 64 arrow contracts, both let kinds, independent byte/address
+fixtures, malformed encodings, every fixture truncation, and trailing bytes.
+The VM suite also checks all 11 counted decoding paths with a complete
+single-element input and truncated inputs declaring two or `UInt64.max`
+elements. These 66 checks run through bytecode and source interpretation.
+Malformed cases must reject during decoding, before any reserialization check.
+
+The ordinary production corpus has 6,656 source constants. The serial and
+parallel Lean drivers and Rust emit the same 6,940,577-byte environment, with
+7,404 named entries and no address, byte, or metadata mismatches. Decompilation
+reconstructs all 6,656 source constants with no errors or mismatches. The
+low-level diagnostic probes retain their existing mismatch baselines; the
+production-driver and fidelity gates require zero mismatches.
+
+## Formal trust frontier
+
+The compiler manifest audits 143 roots. The typechecker manifests audit 2,034
+completed roots, one conditional root, and seven statement roots. Their
+existing transitive assumptions remain explicit in the manifests. Both local
+sorry-frontier checks pass.
+
+The new resource audit covers 15 roots connected to executable quantitative,
+scope, ownership, loan-ending, and join checks. Contract-code inverses and
+quantitative laws use the implemented finite domains. No new axioms or local
+`sorry` placeholders were added.
+
+These results establish the stated codec and state-transition properties.
+They do not establish a theorem for the entire resource checker against a
+machine operational semantics or verify a backend allocation strategy.
+
+## Migration observations
+
+Environment format is 3, catalog-manifest format is 2, and claim/proof envelopes
+bind format 3 plus a validator identity. Old typed objects, claims, and
+primitive addresses require regeneration. The historical Mathlib proof fixture
+retains its original hash and root bytes and now rejects at the v3 envelope
+boundary.
+
+The v3 VM's decoding and canonicality checks change its deterministic FFT-cost
+estimates. Across the 83 existing kernel pins the increase over the pre-v3
+baseline is 0.008%–1.278%; `Nat.add_comm` changes from 321,012,193 to 322,598,714.
+The shard fixture changes from 6,999,296,124 to 7,072,190,269 (+1.041%). Exact
+equality assertions are retained when migrating these pins.
+
+An initial v3 implementation traversed counted byte sequences before parsing
+them. Removing those preliminary walks preserves rejection through strict
+incremental reads and reduces every kernel pin, by 0.021%–6.975%. For
+`Nat.add_comm`, the cost falls from 336,711,085 to 322,598,714 (-4.191%), removing
+89.894% of its initial v3 increase. The shard falls from 7,645,795,797 to
+7,072,190,269 (-7.502%). The generated VM and bytecode interpreter agree on the
+new per-circuit counts. These figures are deterministic estimates of FFT work.
+
+The v3 suite and primitive-closure validation are registered in CI. This record
+does not claim execution of the specialized CUDA, SP1, or Zisk toolchain jobs.
diff --git a/docs/resource-checking.md b/docs/resource-checking.md
new file mode 100644
index 000000000..a72824d39
--- /dev/null
+++ b/docs/resource-checking.md
@@ -0,0 +1,178 @@
+# Ixon v3 resource checking
+
+The Lean and Rust resource validators consume the same canonical addressed
+environment and an explicit profile. Both production compilers run this
+validation, together with erased typechecking, before emitting annotated
+constants. Resource claims bind the complete constant set and profile address.
+
+The executable modules are [Basic](../Ix/Resource/Basic.lean),
+[Check](../Ix/Resource/Check.lean), and [Admit](../Ix/Resource/Admit.lean).
+[Rust](../crates/ixon/src/resource.rs) implements the same transitions.
+The production boundaries are [Validate](../Ix/Resource/Validate.lean) and
+[the Rust kernel adapter](../crates/kernel/src/resource.rs).
+
+## Preconditions and admission
+
+Resource checking supplements ordinary typechecking. The
+[address adapter](../Ix/Resource/Addressed.lean) verifies raw bytes, hashes,
+canonical decoding, projection wrappers, reference closure, and blob identity.
+It ignores optional metadata and materialized caches. It constructs a program
+whose declaration kinds, references, sharing expansions, and field rules come
+from verified addressed constants. Its internal global indices are analysis
+data; they are not a new expression encoding. A successful call on a manually
+constructed `Program` is conditional on those prerequisites.
+
+Admission computes which declarations have resource obligations. A contract
+on a declaration, a referenced interface, or another member of the same
+addressed mutual block makes the declaration subject to resource checking.
+This prevents an ordinary-looking alias from erasing an imported contract.
+Wholly ordinary components retain their ordinary typechecking path.
+
+Resource-bearing definitions are checked against their interfaces. Constructors
+must retain local, finite-use, and unique captures in every partial application
+and in the final result. External resource interfaces, special selection
+behavior, and shareable representations require explicit profile entries.
+The canonical profile binds those entries to addresses.
+They cannot be inferred from names or optional source metadata.
+
+## Uses and availability
+
+Demands use the four-element domain `0`, `1`, `&`, and many. Sequential
+demands add, calls scale argument demand by the input contract, and alternative
+paths join. Erased computation and type formation contribute zero demand.
+A binder is checked when its scope finishes; exactly one rejects an optional
+or absent consumption.
+
+Zero demand still checks the full resource structure of argument types. An
+erased owner or view cannot be made usable by borrowing or reborrowing it.
+
+The checker separately records whether each owner is live, still unique, and
+subject to active loans. A unique transfer requires all three conditions:
+live, unique, and no loans. Permanent sharing clears uniqueness. Ending a
+loan removes that loan and preserves both the liveness and sharing state.
+A branch join preserves availability only when every incoming path does.
+
+Constructing a closure transfers captured unique owners. That transfer counts
+even when the closure's body only borrows the captured owner. A reusable shared
+closure cannot hide a finite-use or uniquely consumed capture. A unique
+closure can carry these captures and is consumed when invoked. Borrowing does
+not turn such a closure into a reusable shared callback.
+
+## Scopes and calls
+
+Scopes form an internal parent tree. Values retain all local origins that can
+be reached through them. Checking a local conversion requires each retained
+origin to be an ancestor of the destination scope. Unrestricted conversion
+requires no retained local origin.
+
+The destination of a local call result is inferred from its surrounding use.
+For example, a function can forward a local input through a local identity
+helper and return it to its caller. An inner local let or loan still cannot
+escape: its origin is a younger scope than that return destination.
+
+A call with an unrestricted result checks its local inputs in the current
+scope. This permits a reader to inspect a temporary view and return a fresh,
+unrestricted value. Narrowing that fresh value to an outer local scope does
+not make the inspected view escape.
+
+Ordinary lets use transfer or permanent aliasing. A borrow let resolves its
+initializer to a variable or a supported projection chain, opens a shared
+loan, and adds that scope to the view's origins. Reborrows retain their parent
+origins and root owner. Projected loans suspend the whole owner.
+Capturing a shared view to reborrow it captures that view; it does not transfer
+the root owner whose availability is already suspended by the outer loan.
+
+Closures and aggregates retain origins. Projection rules preserve the field's
+ownership restrictions: a shared aggregate cannot expose a stored unique
+closure as a reusable shared function. Every returned place is materialized
+before the lexical scope ends, so inference cannot defer a prohibited move
+until after a loan has been removed.
+
+## Explicit bounds of the initial checker
+
+The checker requires visible arrow interfaces after bounded beta, let, sharing,
+and definition reduction. Higher-order types must agree in every contract.
+It does not guess a resource interface when normalization is unsupported.
+Abstract unique function values are not assumed safe to borrow as reusable
+callbacks. A representation needs a checked or explicitly admitted rule before
+the checker grants that permission.
+
+Field rules must be derived from transparent constructor interfaces. The
+initial projection fragment requires closed field types and field usage
+`many`; other projection transformations are rejected before artifact emission.
+It does not split availability between fields of the same owner.
+
+Special alternative-path analysis requires a profile-bound selection primitive
+with the specified evaluation behavior. Such a primitive must be fully applied
+and cannot escape through an ordinary callback value. An arbitrary ordinary
+function does not acquire branch semantics because its name resembles a
+conditional.
+
+Recursion uses the declared interfaces of the mutually checked definitions.
+Calls conservatively retain all origins permitted by those interfaces, rather
+than assuming that an unknown recursive body has no captures. Ordinary
+typechecking remains responsible for the language's recursion admissibility.
+
+The default analysis bounds are depth 256 and 100,000 steps per declaration.
+Exhaustion is a rejection. Open sharing is analyzed in each binding context;
+its resource result is never cached by expression identity alone.
+
+## Profiles, claims, and consumers
+
+A canonical profile begins with the UTF-8 bytes
+`ixon-v3/resource-v1/profile` and a zero byte, followed by:
+
+1. Assumptions, shareable type addresses, and selection primitive addresses:
+   each list has a minimal Tag0 count and strictly increasing 32-byte addresses.
+2. Optional Nat and String type addresses: a byte `0`, or `1` and an address.
+3. Nonzero depth and step limits, each a minimal Tag0 unsigned integer.
+
+Selection primitives must also be assumptions. Literal types, when selected,
+must match the kernel's pinned v3 primitive identities. The profile address is
+BLAKE3 of these exact bytes. Changing limits or assumptions changes the claim.
+The default profile admits no external resource interfaces and only grants
+shareability to present canonical Nat, Bool, and String types.
+
+`makeClaim` validates before producing a `Resource` claim. `checkClaim` checks
+the complete subject root and profile address, then reruns combined validation.
+The claim has format byte `3` and validator byte `2` (`resource-v1`).
+Assumptions describe admitted behavior; they do not remove constants from the
+required closure. Merely parsing a claim or proof wrapper validates no program.
+
+| Consumer | Advertised validation |
+| --- | --- |
+| Lean and Rust resource admission | Resources plus erased typing, with a committed profile |
+| Ix.Tc and the Rust ordinary kernel | Erased Lean typing |
+| IxVM `Check` and `CheckEnv` | Erased Lean typing, validator byte `1` |
+| IxVM `Reveal` and `Contains` | Structural validation, validator byte `0` |
+| IxVM `Resource` | Explicitly unsupported; native success is not a circuit proof |
+
+IxVM preserves all v3 fields in serialization and revelation. Its typing
+conversion erases contracts and interprets a borrow let as an ordinary let.
+The committed validator identity prevents these typing proofs from claiming
+resource validity. Backends relying on ownership or locality must require
+resource admission separately. The [consumer handoff](compilatrix-ixon-v3.md)
+records the supported interfaces and migration fixtures.
+
+## Verification and regression coverage
+
+Lean proofs connect the executed checks to these facts:
+
+- accepted demands cover the admitted natural-number consumptions;
+- the bounded ancestor walk establishes lexical containment;
+- allocating a scope preserves the backwards-pointing parent tree;
+- a fresh scope cannot escape to an older scope;
+- moving requires a live unique owner without loans;
+- sharing permanently clears unique availability;
+- ending a loan preserves liveness and uniqueness;
+- joins only preserve availability present on both paths.
+
+These are executable-check and transition invariants. They do not replace the
+ordinary typechecking prerequisite or claim a proof of a machine backend's
+allocation behavior.
+
+[Shared resource fixtures](../Tests/Fixtures/ixon-v3/resource.tsv) exercise
+accepted and rejected terms in both implementations. The suites also cover
+all 64 input/result combinations, imported-interface aliases, mutual groups,
+profile omissions, constructor captures, and bounded rejection of cyclic
+sharing. Tests explicitly distinguish wire validity from resource admission.
diff --git a/docs/source-contracts.md b/docs/source-contracts.md
new file mode 100644
index 000000000..005bbdbb6
--- /dev/null
+++ b/docs/source-contracts.md
@@ -0,0 +1,202 @@
+# Source contracts for the Ix frontend
+
+The Ix frontend records three independent properties: usage, ownership, and
+relative locality. Aiur is one consumer of this shared frontend.
+
+The source frontend resolves exact binder occurrences before canonicalization
+and sharing. Both environment compilers preserve those contracts in Ixon v3
+and run resource and erased-type validation before emitting annotated output.
+Persistent registrations and annotations survive imports. The decompiler
+reconstructs committed contracts independently of optional presentation data.
+
+The [native resource checker](resource-checking.md) also implements usage,
+ownership, scopes, captures, and loan checks, with shared Lean/Rust fixtures
+and proofs of the executed state invariants.
+
+The admitted source fragment includes definitions, theorems, opaque bodies,
+and explicitly admitted external interfaces. Annotated inductive/constructor/
+recursor generation and nonidentity compiler surgery currently report an
+unsupported transformation before emission. Ordinary source keeps its existing
+compilation path. Source syntax alone does not establish resource validity.
+
+The complete semantic and binary design is in [Ixon v3](Ixon-v3.md).
+
+## Modes
+
+| Axis | Source prefix | Meaning |
+| --- | --- | --- |
+| Usage | `0` | Erased |
+| Usage | `1` | Exactly one computational consumption |
+| Usage | `&` | At most one computational consumption |
+| Usage | Unmarked | Any number of computational consumptions |
+| Ownership | `!` | Unique ownership |
+| Ownership | Unmarked | Shared access |
+| Locality | `~` | Confined to an implicit scope |
+| Locality | Unmarked | Unrestricted escape |
+
+`~!` combines local scope with unique ownership. Neither property changes
+usage. For example, `(! x : A)` means unique ownership with unrestricted
+usage; the availability check must still prevent two unique transfers.
+
+Prefix components must be adjacent, with a space before the binder name.
+Each axis may appear at most once. The parser accepts both `!1` and `1!`,
+and both `~!&` and `&~!`.
+
+## Source syntax
+
+Import `Ix.Compile.SourceContract.Elab`:
+
+```lean
+import Ix.Compile.SourceContract.Elab
+
+def identityLocal {0 A : Type} (~!1 x : A) : ~! A := x
+
+def curried (x y : Nat) : ~ Nat := x + y
+
+def localArrow : (~ _x : Nat) → ~ Nat := fun x => x
+
+def localLambda := fun (~1 x : Nat) => x
+
+def localBinding (x : Nat) : Nat :=
+  let (~!1 y : Nat) := x
+  y
+```
+
+These are declarations of intent. The source layer records their contracts;
+the resource checker determines which programs satisfy them.
+
+Annotations work in `def` headers, nested `fun` and `forall` binders,
+dependent arrows, ordinary arrows with annotated results, and lets. Explicit
+`(...)`, implicit `{...}`, strict implicit `⦃...⦄`, and named instance
+`[...]` binders are supported. An annotated binder has one name and an
+explicit type. Ordinary binders may share a type or use Lean's existing
+inference.
+
+Results use `: ~! A`, `→ ~! A`, or `∀ ..., ~! A`; any ownership/locality
+combination is available, and unmarked means shared and unrestricted.
+The result contract belongs to one arrow. In the `curried` example, the
+intermediate function after `x` has the ordinary result contract; only the
+arrow after `y` has a local result.
+
+A lambda's input annotation is separate from its expected arrow's result
+contract. Use an annotated function type to state a nested lambda's result.
+A final declaration binder with a default value currently needs an explicit
+arrow type for its result contract; the shorthand reports this limitation.
+
+Ordinary definitions, attributes, private declarations, auto-implicit
+parameters, native borrowing metadata, and inferred result types retain Lean's
+existing behavior. Named lifetime syntax and `regions ... in` are removed.
+
+## Scoped shared borrowing
+
+An explicit borrow let creates a temporary shared view:
+
+```text
+let count :=
+  let borrow (~ view : Buffer) := owner
+  inspect view
+
+consumeUnique owner count
+```
+
+Its initializer identifies an owner binding or supported projection path. The
+view is shared and local; it cannot be unique. The inner body's scope bounds
+the loan. Creating a view does not consume its owner, and uses of the view
+count against the view's own usage annotation.
+
+The resource checker suspends unique access while the loan is active,
+rejects escaped views and captures, and ends the loan when the body finishes.
+Unique access returns only for an owner that remains live and exclusive.
+Returning an independent result from `inspect` can end the loan; returning
+`view` cannot.
+
+The frontend records this as the existing Ixon let with
+`LetKind.borrowShared`. An ordinary `let (~ x : A) := value` has
+`LetKind.value`: locality by itself does not create a temporary loan.
+
+Lean's `@&` remains an independent native calling-convention hint. For example,
+`(~!& x : @& A)` preserves the native singleton metadata wrapper as well as
+the source contract. That hint grants no ownership or locality facts.
+
+## Pure input and source identity
+
+`Ix.Compile.CompileInput` contains selected `(Name × ConstantInfo)` entries,
+an explicit array of `SourceContract` records, and optional measure hints.
+The semantic contract array has no default. `CompileInput.plain` explicitly
+selects ordinary source; validation rejects it if that source contains markers.
+
+`CompileInput.resolve` does not consult a Lean environment. It checks:
+
+- Selected names and declarations agree, and selected entries are unique.
+- Each contract matches the complete source snapshot, including types, bodies,
+  universes, declaration fields, binder information, names, and metadata.
+- Each site identifies an actual lambda, forall, or let. A site consists of a
+  type/body root and a structural expression path, including metadata edges.
+- Sites are unique, and corresponding declaration inputs agree on all axes.
+- Only arrows carry result contracts, and only lets carry a borrow kind.
+- Explicit shared-borrow views are shared and local.
+- Source markers match supplied records exactly, including result and let kind.
+- Unsupported telescope correspondences fail before canonicalization.
+
+Source names and offsets help validate and diagnose annotations. Resolved
+semantic records use structural sites; their meaning does not depend on
+binder spelling. Expected arrow domains copied into alpha-renamed lambdas
+must match the original validated marker. Source snapshots themselves still
+compare exactly, so renaming invalidates a previously captured snapshot.
+
+Default inputs are many/shared/unrestricted. Default arrow results are
+shared/unrestricted. An implicit or instance binder is not automatically erased.
+
+## Registration and imports
+
+`SourceContract.ofTelescope source requests` expands declaration shorthand
+into separate type and body sites. Positions are zero-based and include
+implicit and instance arguments; a name selector must be unambiguous.
+
+```lean
+SourceContract.ofTelescope source #[
+  { binder := .position 0, uses := .linear,
+    value := .localUnique, result := some .localUnique }
+]
+```
+
+The body binder receives the input contract. Only the corresponding forall
+receives the result contract.
+
+`registerSourceContract` and `registerMeasureHint` persist validated records.
+Disjoint patches accumulate; duplicate sites and conflicting imported patches
+are diagnosed. `compileInputFromEnv env selected` exports only selected
+declarations and validates the resulting pure input. Compiler loading needs
+the full-content Lean environment, including imported and opaque bodies.
+
+Markers use schema 3 in the reserved `ix.source.binder` metadata namespace.
+Input contracts use the same four mode bits as Ixon. Results and let kinds
+are explicit fields. Unknown keys, duplicate keys, invalid bits, and older
+schemas are rejected; optional optimization metadata cannot replace them.
+
+## Measure proposals and verification
+
+`compileLeanInput` and `rsCompileInput` accept an explicit `CompileInput` and
+an optional resource profile. Environment-aware compiler entrypoints also
+collect persistent registrations; constant-list entrypoints collect source
+annotations. The native profile FFI decodes canonical profile bytes itself.
+Raw Rust FFI entrypoints reject unresolved source markers.
+
+The intermediate `ix.contract` namespace is reserved. Its fields are consumed
+into semantic binder data before output; they are not optional metadata.
+Malformed frames, metadata replay that would erase contracts, incomplete
+closures, and resource-invalid bodies fail before annotated artifacts appear.
+See [resource checking](resource-checking.md) for profile and claim rules.
+
+Measure hints bind an exact source snapshot to an elaborated argument position
+and an optional positive fixed-step proposal. They add no runtime parameter
+and certify neither termination nor a cycle bound. They remain separate from
+semantic contracts; a hint-only change preserves ordinary production bytes.
+
+The focused `source-contract-tests` target checks source identity, distinct
+occurrences of equal terms, every arrow contract, syntax, imported interfaces,
+native metadata, result placement, both let kinds, and rejection of unadmitted
+external interfaces before artifacts are written. Syntax fixtures also reject accidental
+`sorryAx` insertion. The `ixon-v3-tests` target separately exercises binary
+representations, FFI, sharing hashes, accepted compilation and decompilation,
+resource admission, VM execution, interpretation, and proving.
diff --git a/flake.nix b/flake.nix
index 84079f7f7..bc6f1deb8 100644
--- a/flake.nix
+++ b/flake.nix
@@ -109,7 +109,14 @@
 
           # Rust package
           craneLib = (crane.mkLib pkgs).overrideToolchain rustToolchain;
-          src = craneLib.cleanCargoSource ./.;
+          # Rust tests embed the shared golden and binary handoff fixtures.
+          src = pkgs.lib.fileset.toSource {
+            root = ./.;
+            fileset = pkgs.lib.fileset.unions [
+              (pkgs.lib.fileset.fromSource (craneLib.cleanCargoSource ./.))
+              ./Tests/Fixtures/ixon-v3
+            ];
+          };
           craneArgs = {
             inherit src;
             pname = "ix";
diff --git a/lakefile.lean b/lakefile.lean
index 98fe391ce..d5a54ef55 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -158,6 +158,22 @@ lean_exe «arena-exclude» where
   root := `Tests.Ix.Kernel.ArenaExclude
   supportInterpreter := true
 
+/-- Focused source-contract checks, including fresh-module registration export. -/
+lean_exe «source-contract-tests» where
+  root := `Tests.SourceContractMain
+  supportInterpreter := true
+
+/-- Focused v3 codec, locality, and cross-language transport checks. -/
+lean_exe «ixon-v3-tests» where
+  root := `Tests.IxonV3Main
+  moreLinkObjs := #[ix_rs_test]
+
+/-- Regenerate format-specific primitive identities from the installed Lean environment. -/
+lean_exe «ixon-v3-primitives» where
+  root := `Tests.IxonV3Primitives
+  supportInterpreter := true
+  moreLinkObjs := #[ix_rs_test]
+
 end Tests
 
 section Benchmarks