From fa481942e4f526a61e19e7862398cc2e7113989a Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 15 Sep 2026 13:40:37 -0400
Subject: [PATCH 1/5] feat(frontend): elaborate binder ownership and region
 contracts

---
 Ix/Compile/SourceContract.lean             |   4 +
 Ix/Compile/SourceContract/Basic.lean       | 211 +++++++++++++
 Ix/Compile/SourceContract/Elab.lean        | 132 ++++++++
 Ix/Compile/SourceContract/Marker.lean      | 119 +++++++
 Ix/Compile/SourceContract/Registry.lean    |  90 ++++++
 Ix/Compile/SourceContract/Resolve.lean     | 346 +++++++++++++++++++++
 Ix/Compile/SourceContract/Syntax.lean      |  72 +++++
 Ix/CompileDriver.lean                      |  19 ++
 Tests/Ix/SourceContract.lean               | 289 +++++++++++++++++
 Tests/Ix/SourceContract/Driver.lean        |  75 +++++
 Tests/Ix/SourceContract/ImportCheck.lean   |  69 ++++
 Tests/Ix/SourceContract/Imported.lean      |  42 +++
 Tests/Ix/SourceContract/SyntaxCheck.lean   | 119 +++++++
 Tests/Ix/SourceContract/SyntaxFixture.lean |  63 ++++
 Tests/Main.lean                            |   5 +
 Tests/SourceContractMain.lean              |   8 +
 crates/compile/src/compile/env.rs          |  10 +
 crates/compile/src/graph.rs                | 198 +++++++++++-
 docs/source-contracts.md                   | 206 ++++++++++++
 lakefile.lean                              |   5 +
 20 files changed, 2065 insertions(+), 17 deletions(-)
 create mode 100644 Ix/Compile/SourceContract.lean
 create mode 100644 Ix/Compile/SourceContract/Basic.lean
 create mode 100644 Ix/Compile/SourceContract/Elab.lean
 create mode 100644 Ix/Compile/SourceContract/Marker.lean
 create mode 100644 Ix/Compile/SourceContract/Registry.lean
 create mode 100644 Ix/Compile/SourceContract/Resolve.lean
 create mode 100644 Ix/Compile/SourceContract/Syntax.lean
 create mode 100644 Tests/Ix/SourceContract.lean
 create mode 100644 Tests/Ix/SourceContract/Driver.lean
 create mode 100644 Tests/Ix/SourceContract/ImportCheck.lean
 create mode 100644 Tests/Ix/SourceContract/Imported.lean
 create mode 100644 Tests/Ix/SourceContract/SyntaxCheck.lean
 create mode 100644 Tests/Ix/SourceContract/SyntaxFixture.lean
 create mode 100644 Tests/SourceContractMain.lean
 create mode 100644 docs/source-contracts.md

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..22433e404
--- /dev/null
+++ b/Ix/Compile/SourceContract/Basic.lean
@@ -0,0 +1,211 @@
+module
+
+public import Ix.IxonMode
+
+/-!
+# 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
+  deriving BEq, DecidableEq, Repr, Inhabited
+
+/-- An explicit source annotation. `owned` describes the bound value (`! x`),
+independently of `resultOwned`, which describes an arrow's result. A region
+names a declaration parameter; it does not create a loan. -/
+structure BinderContract where
+  site : BinderSite
+  uses : Ixon.Uses
+  resultOwned : Option Ixon.Owned := none
+  owned : Ixon.Owned := .shared
+  region : Option Lean.Name := none
+  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
+  regions : Array Lean.Name := #[]
+  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.
+Bound-value ownership and region apply to both occurrences; result ownership
+applies only to this position's arrow. -/
+structure TelescopeContract where
+  binder : BinderSelector
+  uses : Ixon.Uses
+  resultOwned : Option Ixon.Owned := none
+  owned : Ixon.Owned := .shared
+  region : Option Lean.Name := none
+  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, resultOwned is always populated, including the shared default.
+On lambdas it is absent. -/
+structure ResolvedBinderContract where
+  site : BinderSite
+  kind : SourceBinderKind
+  name : Lean.Name
+  binderInfo : Lean.BinderInfo
+  uses : Ixon.Uses
+  resultOwned : Option Ixon.Owned
+  owned : Ixon.Owned
+  /-- Zero-based index into this declaration's region parameters. -/
+  region : Option Nat
+  deriving Repr, Inhabited
+
+structure ResolvedSourceContract where
+  source : Lean.ConstantInfo
+  binders : Array ResolvedBinderContract
+  /-- Names are diagnostic source data; resolved references use bound indices. -/
+  regions : Array Lean.Name
+  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
+  resultOwned : Option Ixon.Owned
+  owned : Ixon.Owned
+  region : Option Nat
+  deriving BEq, Repr, Inhabited
+
+/-- Region parameters are identified by their binding positions. Names and the
+exact source snapshot belong to validation and diagnostics, not these assertions.
+Source paths still refer to the elaborated tree; do not hash this as an artifact. -/
+structure SourceContractSemantics where
+  regionParameterCount : Nat
+  binders : Array BinderContractSemantics
+  deriving BEq, Repr, Inhabited
+
+def ResolvedSourceContract.semantics (contract : ResolvedSourceContract) : SourceContractSemantics :=
+  { regionParameterCount := contract.regions.size
+    binders := contract.binders.map fun binder => {
+      site := binder.site, kind := binder.kind, uses := binder.uses
+      resultOwned := binder.resultOwned, owned := binder.owned, region := binder.region } }
+
+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)
+  | ownershipOnLambda (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)
+  | inconsistentOwnership (name : Lean.Name) (index : Nat)
+      (typeOwned bodyOwned : Ixon.Owned)
+  | inconsistentRegion (name : Lean.Name) (index : Nat)
+      (typeRegion bodyRegion : Option Nat)
+  | duplicateRegion (declaration region : Lean.Name)
+  | unknownRegion (declaration region : Lean.Name)
+  | conflictingRegions (declaration : Lean.Name)
+  | 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..ae3732a41
--- /dev/null
+++ b/Ix/Compile/SourceContract/Elab.lean
@@ -0,0 +1,132 @@
+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
+
+/-- Lexical frontend context only. Each marker carries its complete parameter
+table, so imported source validation does not depend on this extension. -/
+meta initialize currentRegions : EnvExtension (Array Lean.Name) ← registerEnvExtension (pure #[])
+
+private meta def decodePrefix (modes : Syntax) : TermElabM (Ixon.Uses × Ixon.Owned × Option Lean.Name) := do
+  let parts := modes.getArgs.filter (!·.isNone)
+  for i in [1:parts.size] do
+    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 owned := if modes[0].isNone then Ixon.Owned.shared else .unique
+  let uses ← if modes[1].isNone then pure Ixon.Uses.many else do
+    let quantity := modes[1][0][0]
+    if quantity.isAtom && quantity.getAtomVal == "&" then pure .affine else
+      match quantity.isNatLit? with
+      | some 0 => pure .erased
+      | some 1 => pure .linear
+      | _ => throwErrorAt quantity "binder usage must be 0, 1, or &"
+  let region := if modes[2].isNone then none else some modes[2][0][1].getId
+  return (uses, owned, region)
+
+-- Internal expansion target. The raw prefix and region table remain syntax
+-- until Lean elaborates the corresponding binder domain.
+syntax (name := annotatedType) "__ix_binder% " num ident Ix.Compile.SourceSyntax.binderPrefix
+    "[" ident,* "]" "(" term ")" : term
+
+@[term_elab annotatedType]
+meta def elabAnnotatedType : TermElab := fun stx expectedType? => do
+  let some origin := stx[1].isNatLit? | throwErrorAt stx "invalid source annotation origin"
+  let (uses, owned, region) ← decodePrefix stx[3]
+  let regions := stx[5].getSepArgs.map (·.getId)
+  if let some name := region then
+    unless regions.contains name do
+      throwErrorAt stx[3] "unbound region '{name}; introduce it with `regions '{name} in`"
+  let annotation : BinderAnnotation := {
+    origin
+    binder := stx[2].getId
+    uses, owned, region, regions }
+  let type ← elabTerm stx[8] expectedType?
+  match annotation.attach type with
+  | .ok expr => return expr
+  | .error error => throwErrorAt stx "{error}"
+
+private meta def rewriteBinder (binder : Syntax) (origin : Nat) (regions : Array Lean.Name) :
+    CommandElabM Syntax := do
+  let kind := binder.getKind
+  unless kind == ``SourceSyntax.explicitBinder || kind == ``SourceSyntax.implicitBinder ||
+      kind == ``SourceSyntax.strictImplicitBinder || kind == ``SourceSyntax.instanceBinder do
+    return binder
+  let name : Ident := ⟨binder[2]⟩
+  let modes : TSyntax ``Ix.Compile.SourceSyntax.binderPrefix := ⟨binder[1]⟩
+  let (_, _, region) ← liftTermElabM (decodePrefix modes.raw)
+  if let some region := region then
+    unless regions.contains region do
+      throwErrorAt modes "unbound region '{region}; introduce it with `regions '{region} in`"
+  let type : Term := ⟨binder[4]⟩
+  let origin : NumLit := ⟨Syntax.mkNumLit (toString origin)⟩
+  let regions := regions.map Lean.mkIdent
+  let marked ← `(__ix_binder% $origin:num $name:ident $modes:binderPrefix
+    [$[$regions:ident],*] ($type))
+  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
+
+@[command_elab Ix.Compile.SourceSyntax.declaration]
+meta def elabDeclaration : CommandElab := fun stx => do
+  let definition := stx[1]
+  let signature := definition[2]
+  let regions := currentRegions.getState (← getEnv)
+  let mut binders := #[]
+  for i in [:signature[0].getNumArgs] do
+    binders := binders.push (← rewriteBinder signature[0][i] i regions)
+  let signature := signature.setKind ``Parser.Command.optDeclSig |>.setArg 0 (mkNullNode binders)
+  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
+
+@[command_elab Ix.Compile.SourceSyntax.regions]
+meta def elabRegions : CommandElab := fun stx => do
+  let previous := currentRegions.getState (← getEnv)
+  let mut regions := previous
+  for parameter in stx[1].getArgs do
+    let name := parameter[1].getId
+    if regions.contains name then throwErrorAt parameter "duplicate region parameter '{name}"
+    regions := regions.push name
+  modifyEnv fun env => currentRegions.setState env regions
+  try
+    elabCommand stx[3]
+  finally
+    modifyEnv fun env => currentRegions.setState env previous
+
+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..ae6ba4cfc
--- /dev/null
+++ b/Ix/Compile/SourceContract/Marker.lean
@@ -0,0 +1,119 @@
+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
+  owned : Ixon.Owned
+  region : Option Lean.Name
+  regions : Array Lean.Name
+  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 1
+    |>.setNat `ix.source.binder.origin annotation.origin
+    |>.setName `ix.source.binder.name annotation.binder
+    |>.setNat `ix.source.binder.uses annotation.uses.toBits.toNat
+    |>.setNat `ix.source.binder.owned annotation.owned.toBits.toNat
+    |>.setSyntax `ix.source.binder.regions
+      (Lean.mkNullNode (annotation.regions.map fun name => (Lean.mkIdent name).raw))
+  if let some region := annotation.region then
+    data := data.setName `ix.source.binder.region region
+  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.uses, `ix.source.binder.owned, `ix.source.binder.regions,
+    `ix.source.binder.region]
+  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 1) := 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 uses) := data.find `ix.source.binder.uses
+    | throw "missing source binder usage"
+  if uses > 3 then throw "invalid source binder usage"
+  let some uses := Ixon.Uses.ofBits? uses.toUInt8
+    | throw "invalid source binder usage"
+  let some (.ofNat owned) := data.find `ix.source.binder.owned
+    | throw "missing source binder ownership"
+  if owned > 1 then throw "invalid source binder ownership"
+  let some owned := Ixon.Owned.ofBits? owned.toUInt8
+    | throw "invalid source binder ownership"
+  let some (.ofSyntax regions) := data.find `ix.source.binder.regions
+    | throw "missing source region parameters"
+  unless regions.isOfKind Lean.nullKind && regions.getArgs.all (·.isIdent) do
+    throw "invalid source region parameters"
+  let region ← match data.find `ix.source.binder.region with
+    | none => pure none
+    | some (.ofName name) => pure (some name)
+    | _ => throw "invalid source region reference"
+  return some {
+    origin, binder, uses, owned, region
+    regions := regions.getArgs.map (·.getId) }
+
+/-- 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..e3e755ce3
--- /dev/null
+++ b/Ix/Compile/SourceContract/Registry.lean
@@ -0,0 +1,90 @@
+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 := #[]
+  let regions := (patches[0]?.map (·.regions)).getD #[]
+  for patch in patches do
+    if patch.source != actual then throw (.staleSource patch.source.name)
+    if patch.regions != regions then throw (.conflictingRegions actual.name)
+    binders := binders ++ patch.binders
+  return { source := actual, binders, regions }
+
+/-- 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)
+    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..9d6735f71
--- /dev/null
+++ b/Ix/Compile/SourceContract/Resolve.lean
@@ -0,0 +1,346 @@
+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) (regions : Array Lean.Name := #[]) :
+    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, resultOwned := contract.resultOwned
+      owned := contract.owned, region := contract.region }
+    if (sourceBody? source).isSome then
+      let some (bodySite, _) := bodies[index]?
+        | throw (.missingBodyBinder source.name index)
+      binders := binders.push {
+        site := bodySite, uses := contract.uses, owned := contract.owned, region := contract.region }
+  return { source, binders, regions }
+
+def resolveBinderContract (source : Lean.ConstantInfo) (regions : Array Lean.Name)
+    (contract : BinderContract) :
+    Except SourceContractError ResolvedBinderContract := do
+  let region ← match contract.region with
+    | none => pure none
+    | some name => match regions.idxOf? name with
+      | some index => pure (some index)
+      | none => throw (.unknownRegion source.name name)
+  let some expr := sourceAtSite? source contract.site
+    | throw (.invalidSite source.name contract.site)
+  match expr with
+  | .lam name _ _ binderInfo =>
+    if contract.resultOwned.isSome then
+      throw (.ownershipOnLambda source.name contract.site)
+    return {
+      site := contract.site
+      kind := .lam
+      name := name
+      binderInfo := binderInfo
+      uses := contract.uses
+      resultOwned := none
+      owned := contract.owned
+      region }
+  | .forallE name _ _ binderInfo =>
+    return {
+      site := contract.site
+      kind := .all
+      name := name
+      binderInfo := binderInfo
+      uses := contract.uses
+      resultOwned := some (contract.resultOwned.getD .shared)
+      owned := contract.owned
+      region }
+  | _ => throw (.expectedBinder source.name contract.site)
+
+def ResolvedSourceContract.usesAt (contract : ResolvedSourceContract)
+    (site : BinderSite) : Ixon.Uses :=
+  ((contract.binders.find? fun binder => binder.site == site).map (·.uses)).getD .many
+
+def ResolvedSourceContract.ownedAt (contract : ResolvedSourceContract)
+    (site : BinderSite) : Ixon.Owned :=
+  ((contract.binders.find? fun binder => binder.site == site).map (·.owned)).getD .shared
+
+def ResolvedSourceContract.regionAt (contract : ResolvedSourceContract)
+    (site : BinderSite) : Option Nat :=
+  (contract.binders.find? fun binder => binder.site == site).bind (·.region)
+
+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 _ _ =>
+    let annotation ← (binderAnnotation? type).mapError (.malformedAnnotation declaration site)
+    if let some annotation := annotation then
+      if annotation.binder != name then
+        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 regions := (acc.binders[0]?.map (·.2.regions)).getD #[]
+  let mut origins : Std.HashSet (SourceRoot × Nat) := {}
+  let mut binders := #[]
+  for (site, annotation) in acc.binders do
+    if annotation.regions != regions then throw (.conflictingRegions source.name)
+    let key := (site.root, annotation.origin)
+    if origins.contains key then throw (.duplicateAnnotation source.name site.root annotation.origin)
+    origins := origins.insert key
+    binders := binders.push {
+      site, uses := annotation.uses, owned := annotation.owned, region := annotation.region }
+  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 typeName != bodyName || 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, resultOwned := none }
+  return { source, binders, regions }
+
+/-- 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 typeOwned := contract.ownedAt typeSite
+      let bodyOwned := contract.ownedAt bodySite
+      if typeOwned != bodyOwned then
+        throw (.inconsistentOwnership contract.source.name index typeOwned bodyOwned)
+      let typeRegion := contract.regionAt typeSite
+      let bodyRegion := contract.regionAt bodySite
+      if typeRegion != bodyRegion then
+        throw (.inconsistentRegion contract.source.name index typeRegion bodyRegion)
+    | 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
+    if expected.regions != contract.regions then throw (.conflictingRegions actual.name)
+    for annotation in expected.binders do
+      let some supplied := contract.binders.find? (·.site == annotation.site)
+        | throw (.missingAnnotation actual.name annotation.site)
+      if supplied.uses != annotation.uses || supplied.owned != annotation.owned ||
+          supplied.region != annotation.region then
+        throw (.conflictingAnnotation actual.name annotation.site)
+  let mut seenRegions : Std.HashSet Lean.Name := {}
+  for region in contract.regions do
+    if seenRegions.contains region then throw (.duplicateRegion actual.name region)
+    seenRegions := seenRegions.insert region
+  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 contract.regions binder)
+  binders := binders.qsort fun a b => compare a.site b.site == .lt
+  let result : ResolvedSourceContract := { source := actual, binders, regions := contract.regions }
+  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..986ccb00d
--- /dev/null
+++ b/Ix/Compile/SourceContract/Syntax.lean
@@ -0,0 +1,72 @@
+module
+
+public import Lean
+
+/-!
+# Binder-prefix grammar
+
+The declaration parser activates only when a header has an annotated binder.
+Region names use a contextual raw apostrophe, leaving Lean character literals
+unchanged. The elaborator is loaded by importing SourceContract.Elab.
+-/
+
+public meta section
+
+namespace Ix.Compile.SourceSyntax
+
+open Lean Parser
+
+@[expose] def regionName := leading_parser rawCh '\'' >> ident
+
+@[expose] def quantity := leading_parser numLit <|> "&"
+
+@[expose] def binderPrefix := leading_parser
+  lookahead (regionName <|> rawCh '!' <|> quantity) >>
+  optional (rawCh '!' (trailingWs := true)) >>
+  optional (notFollowedBy (rawCh '\'') "region name" >> quantity) >>
+  optional regionName
+
+@[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 declarationSignature := leading_parser
+  many (ppSpace >> (annotatedBinder <|> Term.bracketedBinder <|> Term.binderIdent)) >> 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 >>
+  checkStackTop hasAnnotatedBinder "annotated binder" >>
+  Command.declVal >> Command.optDefDeriving
+
+@[expose] def declaration := leading_parser Command.declModifiers false >> definition
+
+@[expose] def regions := leading_parser
+  nonReservedSymbol "regions" (includeIdent := true) >>
+  many1 (ppSpace >> regionName) >> " in " >> commandParser
+
+attribute [command_parser 2000] declaration regions
+
+end Ix.Compile.SourceSyntax
+
+end
diff --git a/Ix/CompileDriver.lean b/Ix/CompileDriver.lean
index a10b8af1f..1779c7717 100644
--- a/Ix/CompileDriver.lean
+++ b/Ix/CompileDriver.lean
@@ -40,6 +40,7 @@ public import Ix.CanonM
 public import Ix.Ground
 public import Ix.CompileM
 public import Ix.AuxGen.CompileAux
+public import Ix.Compile.SourceContract
 public section
 
 namespace Ix.CompileM
@@ -1022,6 +1023,9 @@ def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
     (rustRef : Option (Std.HashMap Name Address) := none)
     (numWorkers : Nat := 32) (dbg : Bool := false)
     : IO (Except String LeanPipelineOut) := do
+  for (name, source) in consts do
+    if Ix.Compile.sourceHasAnnotations source then
+      return .error s!"source binder contracts are not supported by this compiler yet: {name}"
   -- 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
@@ -1155,4 +1159,19 @@ def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
         blockCount := condensed.blocks.size
         digests }
 
+/-- Explicit frontend boundary. Contract resolution runs before compilation.
+The current production emitter accepts only ordinary source; semantic contracts
+are rejected until transport through canonicalization and rewriting is complete.
+Optional measure proposals do not alter ordinary output. -/
+def compileLeanInput (input : Ix.Compile.CompileInput)
+    (rustRef : Option (Std.HashMap Name Address) := none)
+    (numWorkers : Nat := 32) (dbg : Bool := false) :
+    IO (Except String LeanPipelineOut) := do
+  let resolved ← match input.resolve with
+    | .ok resolved => pure resolved
+    | .error error => return .error (toString error)
+  if let some contract := resolved.contracts[0]? then
+    return .error s!"source binder contracts are not supported by this compiler yet: {contract.source.name}"
+  compileLeanConsts resolved.constants rustRef numWorkers dbg
+
 end Ix.CompileM
diff --git a/Tests/Ix/SourceContract.lean b/Tests/Ix/SourceContract.lean
new file mode 100644
index 000000000..0fbdcc56a
--- /dev/null
+++ b/Tests/Ix/SourceContract.lean
@@ -0,0 +1,289 @@
+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.Owned) :=
+  match actual with
+  | .error _ => #[]
+  | .ok contract => contract.binders.map fun binder => (binder.site, binder.uses, binder.resultOwned)
+
+def telescopeTests : TestSeq :=
+  test "identity resolves linear/unique type and linear body at independent sites"
+    (resolvedModes (resolveTelescope (identity) #[{ binder := .position 0, uses := .linear, resultOwned := 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, resultOwned := some .shared }]).isOk) ++
+  test "ownership shorthand affects only the selected curried arrow"
+    (resolvedModes (resolveTelescope curried #[{ binder := .name `y, uses := .linear, resultOwned := 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, resultOwned := 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, resultOwned := some .shared }] } : SourceContract).resolve identity)
+        (.ownershipOnLambda `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 ownershipRegionTests : TestSeq := Id.run do
+  let source := identity
+  let typeSite : BinderSite := ⟨.type, []⟩
+  let bodySite : BinderSite := ⟨.body, []⟩
+  let unique : TelescopeContract := { binder := .position 0, uses := .many, owned := .unique }
+  let regional (name : Name) : TelescopeContract :=
+    { unique with uses := .affine, region := some name }
+  let resolveRegion (names : Array Name) (name : Name) := do
+    (← SourceContract.ofTelescope source #[regional name] names).resolve source
+  let ownershipMismatch : SourceContract := {
+    source, binders := #[{ site := typeSite, uses := .many, owned := .unique }] }
+  let regionMismatch : SourceContract := {
+    source, regions := #[`a],
+    binders := #[{ site := typeSite, uses := .many, region := some `a }] }
+  return test "unique binder ownership is independent of arrow-result ownership"
+      (match resolveTelescope source #[unique] with
+        | .ok result => result.ownedAt typeSite == .unique && result.ownedAt bodySite == .unique &&
+          result.usesAt typeSite == .many &&
+          (result.binders.find? (·.site == typeSite)).bind (·.resultOwned) == some .shared
+        | .error _ => false) ++
+    test "binder ownership composes with all four usages without claiming validity"
+      ([Ixon.Uses.erased, .linear, .affine, .many].all fun uses =>
+        (resolveTelescope source #[{ unique with uses }]).isOk) ++
+    test "region parameters resolve to declaration-local indices on both roots"
+      (match resolveRegion #[`b, `a] `a with
+        | .ok result => result.regionAt typeSite == some 1 && result.regionAt bodySite == some 1 &&
+          result.ownedAt bodySite == .unique && result.usesAt bodySite == .affine
+        | .error _ => false) ++
+    test "renaming a bound region preserves all resolved assertions"
+      (match resolveRegion #[`a] `a, resolveRegion #[`renamed] `renamed with
+        | .ok first, .ok second => first.semantics == second.semantics
+        | _, _ => false) ++
+    test "unbound region names are rejected"
+      (expectError (resolveRegion #[`a] `missing) (.unknownRegion `identity `missing)) ++
+    test "duplicate region parameters are rejected"
+      (expectError (resolveRegion #[`a, `a] `a) (.duplicateRegion `identity `a)) ++
+    test "type and body must agree on binder ownership"
+      (expectError (ownershipMismatch.resolve source)
+        (.inconsistentOwnership `identity 0 .unique .shared)) ++
+    test "type and body must agree on the region bound"
+      (expectError (regionMismatch.resolve source)
+        (.inconsistentRegion `identity 0 (some 0) none))
+
+def markerTests : TestSeq := Id.run do
+  let annotation : BinderAnnotation := {
+    origin := 0, binder := `x, uses := .affine, owned := .unique
+    region := some `a, regions := #[`a] }
+  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, region, 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 owned := .shared } }
+          contract.binders.size == 2 && (contract.resolve marked).isOk &&
+          !(changed.resolve marked).isOk
+        | .error _ => false)
+
+def suite : List TestSeq :=
+  [telescopeTests, occurrenceTests, rejectionTests, inputTests, ownershipRegionTests, 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..ef20868ff
--- /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, owned := .unique
+  region := some `a, regions := #[`a] }
+
+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.startsWith "source binder contracts are not supported"
+  | .ok _ => false
+
+def suite : List TestSeq := [
+  ioTest "Lean constant-list driver rejects source markers before canonicalization" 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 validates and rejects unsupported out-of-band contracts" 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 "source binder contracts are not supported").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..19e2bf635
--- /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 (·.resultOwned) == some .unique 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..c7a8d92c9
--- /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, resultOwned := some .unique }]
+    | 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..0781aeaef
--- /dev/null
+++ b/Tests/Ix/SourceContract/SyntaxCheck.lean
@@ -0,0 +1,119 @@
+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.twoRegions,
+    ``Tests.Ix.SourceContract.SyntaxFixture.renamedRegion,
+    ``Tests.Ix.SourceContract.SyntaxFixture.renamedTwoRegions,
+    ``Tests.Ix.SourceContract.SyntaxFixture.unrestrictedRegion,
+    ``Tests.Ix.SourceContract.SyntaxFixture.uniqueRegion]
+  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.ownedAt ⟨.type, []⟩ == .unique && unique.ownedAt ⟨.body, []⟩ == .unique &&
+      unique.usesAt ⟨.type, []⟩ == .many do
+    throwError "unique unrestricted binder changed meaning"
+  unless (unique.binders.find? (·.site == ⟨.type, []⟩)).bind (·.resultOwned) == 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.ownedAt ⟨.type, []⟩ == .unique &&
+      native.regionAt ⟨.type, []⟩ == some 0 && native.regionAt ⟨.body, []⟩ == some 0 do
+    throwError "combined ownership, usage, and region 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.twoRegions
+  unless pair.regionAt ⟨.type, []⟩ == some 0 &&
+      pair.regionAt ⟨.type, [.binderBody]⟩ == some 1 do
+    throwError "distinct region parameters were conflated"
+  let renamed ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.renamedRegion
+  unless renamed.semantics == native.semantics do
+    throwError "region renaming changed the resolved assertions"
+  let renamedPair ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.renamedTwoRegions
+  unless renamedPair.semantics == pair.semantics do
+    throwError "renaming multiple region and term binders changed the resolved assertions"
+  let unrestricted ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.unrestrictedRegion
+  unless unrestricted.usesAt ⟨.body, []⟩ == .many &&
+      unrestricted.ownedAt ⟨.body, []⟩ == .shared &&
+      unrestricted.regionAt ⟨.body, []⟩ == some 0 do
+    throwError "region-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 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: unbound region 'a; introduce it with `regions 'a in` -/
+#guard_msgs in
+def unboundRegion (&'a x : Nat) : Nat := x
+
+/-- error: duplicate region parameter 'a -/
+#guard_msgs in
+regions 'a 'a in
+def duplicateRegions (&'a x : Nat) : Nat := x
+
+/-- 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
+
+-- A previous `regions ... in` command must not leak to later declarations.
+/-- error: unbound region 'a; introduce it with `regions 'a in` -/
+#guard_msgs in
+def escapedRegionParameter (!&'a x : Nat) : Nat := x
diff --git a/Tests/Ix/SourceContract/SyntaxFixture.lean b/Tests/Ix/SourceContract/SyntaxFixture.lean
new file mode 100644
index 000000000..b999568e8
--- /dev/null
+++ b/Tests/Ix/SourceContract/SyntaxFixture.lean
@@ -0,0 +1,63 @@
+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
+
+regions 'a in
+def nativeBorrow (!&'a x : @& Nat) : Nat := x
+
+regions 'a 'b in
+def twoRegions (!&'a x : Nat) (1'b y : Nat) : Nat := x + y
+
+regions 'renamed in
+def renamedRegion (!&'renamed value : Nat) : Nat := value
+
+regions 'left 'right in
+def renamedTwoRegions (!&'left first : Nat) (1'right second : Nat) : Nat := first + second
+
+regions 'a in
+def unrestrictedRegion ('a x : Nat) : Nat := x
+
+regions 'a in
+def uniqueRegion (!'a x : Nat) : Nat := x
+
+@[inline] private def privateIdentity (!1 x : Nat) : Nat := x
+
+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 : twoRegions 2 5 = 7 := rfl
+example : privateIdentity 4 = 4 := rfl
+example : ordinaryChar = 'a' := rfl
+
+end Tests.Ix.SourceContract.SyntaxFixture
+
+end
diff --git a/Tests/Main.lean b/Tests/Main.lean
index 352efcb34..d02d05ea0 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),
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/compile/src/compile/env.rs b/crates/compile/src/compile/env.rs
index f0f7dd202..af9b67f7c 100644
--- a/crates/compile/src/compile/env.rs
+++ b/crates/compile/src/compile/env.rs
@@ -153,6 +153,16 @@ pub fn compile_env_with_options(
   // 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!(
+        "source binder contracts are not supported by this compiler yet: {}",
+        name.pretty()
+      ),
+    });
+  }
   let graph = scan.graph;
   if *IX_VERBOSE {
     eprintln!(
diff --git a/crates/compile/src/graph.rs b/crates/compile/src/graph.rs
index 4800f5ea1..effec1db9 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 == "source binder contracts are not supported by this compiler yet: 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()
diff --git a/docs/source-contracts.md b/docs/source-contracts.md
new file mode 100644
index 000000000..32299383f
--- /dev/null
+++ b/docs/source-contracts.md
@@ -0,0 +1,206 @@
+# Source contracts for the Aiur frontend
+
+The frontend elaborates binder annotations into source contracts and resolves
+their occurrences before canonicalization or sharing. It supports usage,
+bound-value ownership, declaration region parameters, and measure proposals.
+
+**Current boundary:** syntax, source binding, declaration telescope consistency,
+persistent registration, and pure input export. Resource/borrow checking, the
+Aiur DSL, Ixon contract emission, and artifact export remain subsequent work.
+Both production environment compilers reject marked source before emission.
+`compileLeanInput` also rejects contracts supplied separately from source
+markers, after validating the explicit input.
+
+## Pure input boundary
+
+`Ix.Compile.CompileInput` contains selected `(Name × ConstantInfo)` entries, an
+explicit array of `SourceContract` records, and optional `MeasureHint` records.
+The semantic contract array has no default. `CompileInput.plain` is the explicit
+convenience constructor for ordinary source without contracts.
+Resolution rejects that constructor's result if the source contains annotations.
+
+`CompileInput.resolve` validates this data without accessing a Lean environment:
+
+- Selected names must match their constants and be unique.
+- Each contract names a selected declaration through an exact source snapshot.
+  Comparison includes the type, body, universe parameters, declaration fields,
+  binder information, names, and metadata. A hash match alone is insufficient.
+- A binder site is a type/body root and a structural expression path. It must
+  identify an actual lambda or forall. Names and source offsets are not site IDs.
+- Repeated sites, conflicting type/body usage, input ownership or region bounds,
+  result ownership attached to a lambda, and unsupported telescope
+  correspondences fail with a structured `SourceContractError`.
+- Result ownership applies separately to each arrow. An unspecified result is
+  shared; an unspecified binder usage is many. An implicit binder is not
+  automatically erased.
+- Bound-value ownership (`owned`) is independent of arrow-result ownership
+  (`resultOwned`). Region references must name distinct declaration parameters
+  and resolve to indices in binding order.
+- Resolved records are sorted by declaration name and structural site, making
+  registration order irrelevant to their presentation. Production semantic
+  addressing must still be determined after actual mode emission.
+
+Resolved records are data, not resource-validity proofs. This checker does not
+establish linear use, unique ownership, nested function-type correspondence,
+termination, source typechecking, or erasure safety. A compiler must validate its
+accepted fragment and transport or reject every explicit contract through its
+rewrites before emitting an artifact.
+
+## Registering and exporting
+
+`SourceContract.ofTelescope source requests` expands declaration shorthand to
+separate type and body sites. Selectors can use a zero-based position or an
+unambiguous binder name. Positions count implicit and instance arguments.
+Metadata wrappers are traversed explicitly; the resolver does not normalize
+types or bodies. In particular, a function alias requiring normalization to
+expose a lambda receives `missingBodyBinder`.
+
+For a closed identity declaration, this request specifies the first binder as
+linear and its arrow result as unique:
+
+```lean
+SourceContract.ofTelescope source #[
+  { binder := .position 0, uses := .linear, resultOwned := some .unique }
+]
+```
+
+The resulting type site is `⟨.type, []⟩` and body site is `⟨.body, []⟩`. The
+body site carries no result ownership. Selecting the second argument of a curried
+declaration changes only that arrow's result ownership.
+
+`registerSourceContract` and `registerMeasureHint` add checked records to
+persistent environment extensions. Disjoint contract patches accumulate.
+Imported patches are retained rather than overwritten by declaration name,
+allowing `compileInputFromEnv env selected` to detect conflicting imported
+registrations. It exports only the selected declarations' records and runs the
+pure validator before returning the input.
+
+Compiler loading must use the full-content Lean environment, including opaque
+bodies and imported declarations. The imported-module fixture tests this in a
+separate Lean process; annotations are not reconstructed by rerunning the
+producer module's registration commands.
+
+## Measure proposals
+
+Measure hints carry a source snapshot, a selector resolved to an elaborated
+input position, and an optional positive fixed-step proposal. Each declaration
+has its own position; a single raw index is not shared across mutual members.
+The hint adds no runtime argument, performs no decrement, and certifies neither
+termination nor a target cycle bound. Measure hints remain separate from the
+semantic binder contract array and can be registered on annotated declarations.
+A production regression checks that a hint-only change preserves ordinary bytes.
+
+## Surface syntax
+
+The implemented usage spellings are `(0 x : A)` for erased, `(1 x : A)` for linear,
+`(& x : A)` for affine, and `(x : A)` for many. `&` is the selected affine marker.
+Import `Ix.Compile.SourceContract.Elab` to enable the syntax:
+
+```lean
+import Ix.Compile.SourceContract.Elab
+
+regions 'a in
+def keep (!&'a x : @& Nat) : Nat := x
+```
+
+The selected ownership spelling is `!` before the variable name, with shared
+ownership implicit. Prefix components appear in ownership, usage, region order:
+
+```lean
+(! x : A)       -- unique, unrestricted use
+(!1 x : A)      -- unique, exactly one use
+(!& x : A)      -- unique, at most one use
+(!&'a x : A)    -- unique, at most one use, bounded by region a
+(&'a x : A)     -- shared, at most one use, bounded by region a
+('a x : A)      -- shared, unrestricted use, bounded by region a
+```
+
+All these annotations belong to the binder. A region bound is independent of
+ownership; a region-bounded value need not be a shared loan. Syntax does not
+create a loan or establish uniqueness by itself. The annotation group is compact
+and is separated from the variable name by a space, including `(! x : A)`.
+
+The parser supports `def` header binders in explicit `(...)`, implicit `{...}`,
+strict implicit `⦃...⦄`, and named instance `[...]` forms. Each annotated binder
+has one name and an explicit type. Ordinary binders can be mixed with annotated
+ones. Inferred return types, auto-implicit parameters, dependent binders, private
+definitions, and declaration attributes are covered by fixtures. Annotations on
+`fun`, `forall`, `let`, and other declaration commands remain unsupported.
+
+`regions 'a 'b in <command>` introduces an ordered parameter table for that
+command. Nested commands extend the table, which is restored afterward.
+Duplicate parameters and unbound uses are errors. This introduces region
+parameters, not a runtime borrow operation or lexical loan scope. Ordinary Lean
+character literals and identifiers named `regions` retain their ordinary syntax.
+
+Binder ownership requires a richer contract than the current Ixon v2
+arrow-result field: `! x` must not silently set the ownership of the function's
+result. Result ownership syntax, lexical borrow scopes, and the portable region
+representation remain design work.
+
+Lean already accepts `(x : @& A)` as a native borrowing annotation. Since Lean
+4.30, the compiler can honor it on ordinary and local functions; it remains a
+best-effort reference-counting hint that inference may override, not a checked
+region or uniqueness contract. It stays orthogonal to our binder prefixes;
+`(!&'a x : @& A)` retains the native annotation's singleton outer metadata
+wrapper independently. See the
+[Lean 4.30 release notes](https://lean-lang.org/doc/reference/latest/releases/v4.30.0/).
+
+## Region identity and alpha-invariance
+
+Regions resolve to declaration-local indices: `regions 'a 'b in` binds `'a` at
+0 and `'b` at 1. Consistently renaming the parameters and their uses preserves
+the resolved assertions. Imported-module tests compare
+`ResolvedSourceContract.semantics` for definitions with renamed region and term
+binders, including multiple regions.
+
+That projection contains the region parameter count, occurrence paths, usage,
+input/result ownership, and indexed references. It excludes diagnostic names and
+the source snapshot. Raw records deliberately retain names and the exact source
+for stale-source detection; they must not become artifact hash inputs. The
+projection also remains source data, with paths into the elaborated tree.
+
+**Regions are not represented in emitted Ixon yet.** A future encoding needs
+region binders and indexed references in a namespace separate from term
+variables, with names kept as presentation data. Lexical borrow scopes need
+binding and escape rules. Byte/address equality under alpha-renaming remains an
+acceptance gate for that implementation.
+
+## Elaboration markers
+
+`SourceContract/Syntax.lean` parses annotated headers, and `Elab.lean` delegates
+ordinary declaration elaboration to Lean. Versioned binder-domain markers use
+the reserved `ix.source.binder` metadata namespace. `Marker.lean` rejects unknown
+versions/fields, duplicate fields, malformed values, and overflowing modes.
+Production guards detect reserved keys even if the marker is malformed.
+
+`SourceContract.fromAnnotations` reconstructs records from actual elaborated
+occurrences. Lean can preserve header metadata in the declaration type while
+dropping it from generated lambdas. Pairing then requires a direct type/body
+telescope with matching names, binder information, and domains. The resolver
+does not infer mappings through normalization or other rewrites. Marked raw
+recursor rules are explicitly unsupported.
+
+## Validation
+
+Run the focused build and executable behavior checks:
+
+```sh
+lake build --wfail Tests.SourceContractMain Tests.Main
+lake exe source-contract-tests
+cargo test --release -p ix-compile source_contract
+```
+
+The runtime suite covers mode/site expectations, repeated equal terms, curried
+results, shadowed and implicit binders, source drift, conflicting records, and
+measure resolution. Driver checks exercise missing or unsupported contracts and
+the actual Rust FFI, including absence of output files when partial compilation
+is enabled. Rust tests check deterministic rejection across worker counts and
+native borrow metadata's semantic neutrality. The imported-module build gate
+checks ordinary and opaque bodies, implicit/instance positions, conflicting patches,
+registration accumulation, surface syntax, native borrowing metadata, invalid
+syntax, and alpha-renaming of region and term parameters.
+
+The same checks are registered with the primary `source-contract` test suite and
+the dedicated `source-contract-tests` executable. They validate source-contract
+resolution and export, not production Ixon mode bytes or backend certification.
diff --git a/lakefile.lean b/lakefile.lean
index 98fe391ce..a1549a22b 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -158,6 +158,11 @@ 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
+
 end Tests
 
 section Benchmarks

From dff2c9ffe74499c9129dca03d25819de3b72321a Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Tue, 15 Sep 2026 18:11:26 -0400
Subject: [PATCH 2/5] feat(ixon): implement v3 resource contracts and relative
 locality

---
 .github/workflows/ci.yml                      |     4 +
 .gitignore                                    |     1 +
 Ix/Aggr/Circuit.lean                          |     5 +
 Ix/CanonM.lean                                |     8 +-
 Ix/Catalog.lean                               |     8 +-
 Ix/Claim.lean                                 |    59 +-
 Ix/Cli/CompileCmd.lean                        |     2 +
 Ix/Cli/CompileLeanCmd.lean                    |     7 +-
 Ix/Compile/SourceContract/Basic.lean          |    66 +-
 Ix/Compile/SourceContract/Elab.lean           |   258 +-
 Ix/Compile/SourceContract/Marker.lean         |    60 +-
 Ix/Compile/SourceContract/Registry.lean       |     7 +-
 Ix/Compile/SourceContract/Resolve.lean        |   116 +-
 Ix/Compile/SourceContract/Syntax.lean         |    74 +-
 Ix/Compile/SourceContract/Transport.lean      |   118 +
 Ix/Compile/Verify/Codec.lean                  |   104 +-
 Ix/Compile/Verify/CompileExpr.lean            |    38 +-
 Ix/Compile/Verify/CompileMutualCodec.lean     |    48 +-
 Ix/Compile/Verify/CompilePreseed.lean         |    12 +-
 Ix/Compile/Verify/ConstantCodec.lean          |    54 +-
 Ix/Compile/Verify/ExprCodec.lean              |   139 +-
 Ix/Compile/Verify/ExprSpineCodec.lean         |   243 +-
 Ix/Compile/Verify/IxonValue.lean              |    47 +-
 Ix/Compile/Verify/MutualConstantCodec.lean    |    60 +-
 Ix/Compile/Verify/RecursorConstantCodec.lean  |    36 +-
 Ix/Compile/Verify/Reference.lean              |     7 +-
 Ix/CompileDriver.lean                         |    79 +-
 Ix/CompileM.lean                              |    70 +-
 Ix/DecompileM.lean                            |    27 +-
 Ix/IxVM/ClaimHarness.lean                     |    18 +-
 Ix/IxVM/Convert.lean                          |     5 +
 Ix/IxVM/Ixon.lean                             |    16 +-
 Ix/IxVM/IxonDeserialize.lean                  |   127 +-
 Ix/IxVM/IxonSerialize.lean                    |    63 +-
 Ix/IxVM/Kernel/Check.lean                     |    41 +-
 Ix/IxVM/Kernel/Claim.lean                     |    25 +-
 Ix/IxVM/Kernel/Infer.lean                     |   137 +-
 Ix/IxVM/Kernel/InferOnly.lean                 |    17 +-
 Ix/IxVM/Kernel/NatPrim.lean                   |   365 +-
 Ix/IxVM/Kernel/Whnf.lean                      |    65 +-
 Ix/Ixon.lean                                  |   147 +-
 Ix/IxonContract.lean                          |   222 +
 Ix/IxonMode.lean                              |     6 +-
 Ix/IxonSyntax/AST.lean                        |    36 +-
 Ix/IxonSyntax/Parser.lean                     |    99 +-
 Ix/IxonSyntax/Print.lean                      |    56 +-
 Ix/MultiStark/Aggregate.lean                  |     5 +
 Ix/Resource/Addressed.lean                    |   379 +
 Ix/Resource/Admit.lean                        |   197 +
 Ix/Resource/Audit.lean                        |    28 +
 Ix/Resource/Basic.lean                        |   377 +
 Ix/Resource/Check.lean                        |   536 +
 Ix/Resource/Claim.lean                        |    31 +
 Ix/Resource/Validate.lean                     |    52 +
 Ix/SemanticContract.lean                      |   183 +
 Ix/Sharing.lean                               |   105 +-
 Ix/Tc/Egress.lean                             |    14 +-
 Ix/Tc/Ingress.lean                            |    10 +-
 Ix/Tc/IngressMeta.lean                        |     5 +-
 Ix/Tc/Primitive.lean                          |   175 +-
 Ix/Tc/Verify/Driver/BooleanAcceptance.lean    |    74 +-
 Ix/Tc/Verify/Driver/Dependencies.lean         |    14 +-
 Ix/Tc/Verify/Ingress/SerializedBoolean.lean   |    66 +-
 Tests/AggrSemantics.lean                      |    25 +-
 Tests/Cli.lean                                |    57 +
 Tests/FFI/Ixon.lean                           |     2 +-
 Tests/Fixtures/ixon-v3/addressed.tsv          |     5 +
 Tests/Fixtures/ixon-v3/claims.tsv             |     8 +
 Tests/Fixtures/ixon-v3/expressions.txt        |    12 +
 Tests/Fixtures/ixon-v3/handoff/accepted.claim |     1 +
 Tests/Fixtures/ixon-v3/handoff/accepted.ixe   |   Bin 0 -> 350 bytes
 Tests/Fixtures/ixon-v3/handoff/manifest.json  |    16 +
 Tests/Fixtures/ixon-v3/handoff/profile.bin    |   Bin 0 -> 40 bytes
 .../ixon-v3/handoff/rejected-local-escape.ixe |   Bin 0 -> 350 bytes
 Tests/Fixtures/ixon-v3/primitives.tsv         |    94 +
 Tests/Fixtures/ixon-v3/resource.tsv           |    67 +
 Tests/Fixtures/ixon-v3/text.tsv               |   148 +
 Tests/Gen/Claim.lean                          |     3 +
 Tests/Gen/Ixon.lean                           |    19 +-
 Tests/Gen/IxonSyntax.lean                     |    27 +-
 Tests/Ix/Catalog.lean                         |     5 +-
 Tests/Ix/Claim.lean                           |    31 +-
 Tests/Ix/ClaimsV3.lean                        |    61 +
 Tests/Ix/ContractDecompile.lean               |    52 +
 Tests/Ix/ContractPipeline.lean                |    65 +
 Tests/Ix/ContractTransport.lean               |   109 +
 Tests/Ix/IxVM.lean                            |   173 +-
 Tests/Ix/IxVM/Exploits.lean                   |    18 +-
 Tests/Ix/Ixon.lean                            |     4 +-
 Tests/Ix/IxonSyntax.lean                      |    83 +-
 Tests/Ix/IxonV3.lean                          |   117 +
 Tests/Ix/IxonV3FFI.lean                       |    42 +
 Tests/Ix/IxonV3Text.lean                      |    67 +
 Tests/Ix/IxonV3VM.lean                        |   257 +
 Tests/Ix/Resource.lean                        |   285 +
 Tests/Ix/ResourceAddressed.lean               |   159 +
 Tests/Ix/ResourceAdmit.lean                   |    81 +
 Tests/Ix/ResourceValidate.lean                |    33 +
 Tests/Ix/Sharing.lean                         |     8 +-
 Tests/Ix/SourceContract.lean                  |    94 +-
 Tests/Ix/SourceContract/Driver.lean           |    12 +-
 Tests/Ix/SourceContract/ImportCheck.lean      |     2 +-
 Tests/Ix/SourceContract/Imported.lean         |     2 +-
 Tests/Ix/SourceContract/SyntaxCheck.lean      |   131 +-
 Tests/Ix/SourceContract/SyntaxFixture.lean    |    35 +-
 Tests/Ix/Tc/Roundtrip.lean                    |     2 +-
 Tests/IxonV3Handoff.lean                      |    52 +
 Tests/IxonV3Main.lean                         |    52 +
 Tests/IxonV3Primitives.lean                   |    22 +
 Tests/Main.lean                               |    22 +-
 crates/common/src/prim_addrs.rs               |   174 +-
 crates/compile/src/compile.rs                 |    72 +-
 crates/compile/src/compile/env.rs             |    52 +-
 crates/compile/src/decompile.rs               |    35 +-
 crates/compile/src/graph.rs                   |     6 +-
 crates/compile/src/lib.rs                     |     1 +
 crates/compile/src/semantic_contract.rs       |   577 +
 crates/ffi/src/compile.rs                     |   152 +-
 crates/ffi/src/kernel.rs                      |     8 +-
 crates/ffi/src/lean.rs                        |     9 +-
 crates/ffi/src/lean_env.rs                    |    37 +-
 crates/ffi/src/lean_ixon.rs                   |     1 +
 crates/ffi/src/lean_ixon/contract.rs          |    72 +
 crates/ffi/src/lean_ixon/expr.rs              |    69 +-
 crates/ixon/src/catalog.rs                    |    21 +-
 crates/ixon/src/contract.rs                   |   231 +
 crates/ixon/src/expr.rs                       |   155 +-
 crates/ixon/src/lib.rs                        |    30 +-
 crates/ixon/src/proof.rs                      |   166 +-
 crates/ixon/src/resource.rs                   |  1838 +
 crates/ixon/src/resource/addressed.rs         |  1029 +
 crates/ixon/src/serialize.rs                  |   767 +-
 crates/ixon/src/sharing.rs                    |   398 +-
 crates/ixon/src/syntax/ast.rs                 |    13 +-
 crates/ixon/src/syntax/mod.rs                 |   186 +-
 crates/ixon/src/syntax/parse.rs               |   149 +-
 crates/ixon/src/syntax/print.rs               |    90 +-
 crates/ixon/src/syntax/props.rs               |    25 +-
 crates/ixon/src/tag.rs                        |     9 +
 crates/ixvm-codegen/src/aiur_ix_aggr.rs       |    50 +-
 crates/ixvm-codegen/src/aiur_ixvm.rs          | 30831 ++++++++--------
 crates/ixvm-codegen/src/aiur_multi_stark.rs   |    50 +-
 crates/kernel/src/ingress.rs                  |     4 +-
 crates/kernel/src/lib.rs                      |     1 +
 crates/kernel/src/resource.rs                 |   264 +
 docs/Ixon-v3.md                               |   230 +
 docs/Ixon.md                                  |   173 +-
 docs/compilatrix-ixon-v3.md                   |    80 +
 docs/ixon-text-v3.md                          |   106 +
 docs/ixon-v3-verification.md                  |   106 +
 docs/resource-checking.md                     |   178 +
 docs/source-contracts.md                      |   370 +-
 lakefile.lean                                 |    11 +
 153 files changed, 28534 insertions(+), 18305 deletions(-)
 create mode 100644 Ix/Compile/SourceContract/Transport.lean
 create mode 100644 Ix/IxonContract.lean
 create mode 100644 Ix/Resource/Addressed.lean
 create mode 100644 Ix/Resource/Admit.lean
 create mode 100644 Ix/Resource/Audit.lean
 create mode 100644 Ix/Resource/Basic.lean
 create mode 100644 Ix/Resource/Check.lean
 create mode 100644 Ix/Resource/Claim.lean
 create mode 100644 Ix/Resource/Validate.lean
 create mode 100644 Ix/SemanticContract.lean
 create mode 100644 Tests/Fixtures/ixon-v3/addressed.tsv
 create mode 100644 Tests/Fixtures/ixon-v3/claims.tsv
 create mode 100644 Tests/Fixtures/ixon-v3/expressions.txt
 create mode 100644 Tests/Fixtures/ixon-v3/handoff/accepted.claim
 create mode 100644 Tests/Fixtures/ixon-v3/handoff/accepted.ixe
 create mode 100644 Tests/Fixtures/ixon-v3/handoff/manifest.json
 create mode 100644 Tests/Fixtures/ixon-v3/handoff/profile.bin
 create mode 100644 Tests/Fixtures/ixon-v3/handoff/rejected-local-escape.ixe
 create mode 100644 Tests/Fixtures/ixon-v3/primitives.tsv
 create mode 100755 Tests/Fixtures/ixon-v3/resource.tsv
 create mode 100644 Tests/Fixtures/ixon-v3/text.tsv
 create mode 100644 Tests/Ix/ClaimsV3.lean
 create mode 100644 Tests/Ix/ContractDecompile.lean
 create mode 100644 Tests/Ix/ContractPipeline.lean
 create mode 100644 Tests/Ix/ContractTransport.lean
 create mode 100644 Tests/Ix/IxonV3.lean
 create mode 100644 Tests/Ix/IxonV3FFI.lean
 create mode 100644 Tests/Ix/IxonV3Text.lean
 create mode 100644 Tests/Ix/IxonV3VM.lean
 create mode 100644 Tests/Ix/Resource.lean
 create mode 100644 Tests/Ix/ResourceAddressed.lean
 create mode 100644 Tests/Ix/ResourceAdmit.lean
 create mode 100644 Tests/Ix/ResourceValidate.lean
 create mode 100644 Tests/IxonV3Handoff.lean
 create mode 100644 Tests/IxonV3Main.lean
 create mode 100644 Tests/IxonV3Primitives.lean
 create mode 100644 crates/compile/src/semantic_contract.rs
 create mode 100644 crates/ffi/src/lean_ixon/contract.rs
 create mode 100644 crates/ixon/src/contract.rs
 create mode 100644 crates/ixon/src/resource.rs
 create mode 100644 crates/ixon/src/resource/addressed.rs
 create mode 100644 crates/kernel/src/resource.rs
 create mode 100644 docs/Ixon-v3.md
 create mode 100644 docs/compilatrix-ixon-v3.md
 create mode 100644 docs/ixon-text-v3.md
 create mode 100644 docs/ixon-v3-verification.md
 create mode 100644 docs/resource-checking.md

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/Basic.lean b/Ix/Compile/SourceContract/Basic.lean
index 22433e404..76547b18d 100644
--- a/Ix/Compile/SourceContract/Basic.lean
+++ b/Ix/Compile/SourceContract/Basic.lean
@@ -1,6 +1,6 @@
 module
 
-public import Ix.IxonMode
+public import Ix.IxonContract
 
 /-!
 # Source contracts before canonicalization
@@ -46,17 +46,17 @@ structure BinderSite where
 inductive SourceBinderKind where
   | lam
   | all
+  | letE
   deriving BEq, DecidableEq, Repr, Inhabited
 
-/-- An explicit source annotation. `owned` describes the bound value (`! x`),
-independently of `resultOwned`, which describes an arrow's result. A region
-names a declaration parameter; it does not create a loan. -/
+/-- 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
-  resultOwned : Option Ixon.Owned := none
-  owned : Ixon.Owned := .shared
-  region : Option Lean.Name := none
+  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,
@@ -66,7 +66,6 @@ alone cannot authorize reusing contracts for different source syntax. -/
 structure SourceContract where
   source : Lean.ConstantInfo
   binders : Array BinderContract
-  regions : Array Lean.Name := #[]
   deriving Repr, Inhabited
 
 /-- User-facing selectors are resolved once to elaborated telescope positions.
@@ -77,14 +76,14 @@ inductive BinderSelector where
   deriving BEq, Repr, Inhabited
 
 /-- Declaration shorthand that annotates corresponding type/body binders.
-Bound-value ownership and region apply to both occurrences; result ownership
-applies only to this position's arrow. -/
+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
-  resultOwned : Option Ixon.Owned := none
-  owned : Ixon.Owned := .shared
-  region : Option Lean.Name := none
+  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.
@@ -107,25 +106,22 @@ def CompileInput.plain (constants : List (Lean.Name × Lean.ConstantInfo)) : Com
   { constants, contracts := #[] }
 
 /-- Diagnostic names and binder information are retained after resolving a
-site. On arrows, resultOwned is always populated, including the shared default.
-On lambdas it is absent. -/
+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
-  resultOwned : Option Ixon.Owned
-  owned : Ixon.Owned
-  /-- Zero-based index into this declaration's region parameters. -/
-  region : Option Nat
+  result : Option Ixon.ValueContract
+  value : Ixon.ValueContract
+  letKind : Ixon.LetKind
   deriving Repr, Inhabited
 
 structure ResolvedSourceContract where
   source : Lean.ConstantInfo
   binders : Array ResolvedBinderContract
-  /-- Names are diagnostic source data; resolved references use bound indices. -/
-  regions : Array Lean.Name
   deriving Repr, Inhabited
 
 /-- The resolved assertion at one source occurrence, without diagnostic names.
@@ -134,24 +130,21 @@ structure BinderContractSemantics where
   site : BinderSite
   kind : SourceBinderKind
   uses : Ixon.Uses
-  resultOwned : Option Ixon.Owned
-  owned : Ixon.Owned
-  region : Option Nat
+  result : Option Ixon.ValueContract
+  value : Ixon.ValueContract
+  letKind : Ixon.LetKind
   deriving BEq, Repr, Inhabited
 
-/-- Region parameters are identified by their binding positions. Names and the
-exact source snapshot belong to validation and diagnostics, not these assertions.
+/-- 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
-  regionParameterCount : Nat
   binders : Array BinderContractSemantics
   deriving BEq, Repr, Inhabited
 
 def ResolvedSourceContract.semantics (contract : ResolvedSourceContract) : SourceContractSemantics :=
-  { regionParameterCount := contract.regions.size
-    binders := contract.binders.map fun binder => {
+  { binders := contract.binders.map fun binder => {
       site := binder.site, kind := binder.kind, uses := binder.uses
-      resultOwned := binder.resultOwned, owned := binder.owned, region := binder.region } }
+      result := binder.result, value := binder.value, letKind := binder.letKind } }
 
 structure ResolvedMeasureHint where
   source : Lean.ConstantInfo
@@ -175,7 +168,9 @@ inductive SourceContractError where
   | staleSource (name : Lean.Name)
   | invalidSite (name : Lean.Name) (site : BinderSite)
   | expectedBinder (name : Lean.Name) (site : BinderSite)
-  | ownershipOnLambda (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)
@@ -183,13 +178,8 @@ inductive SourceContractError where
   | missingBodyBinder (name : Lean.Name) (index : Nat)
   | inconsistentTelescope (name : Lean.Name) (index : Nat)
       (typeUses bodyUses : Ixon.Uses)
-  | inconsistentOwnership (name : Lean.Name) (index : Nat)
-      (typeOwned bodyOwned : Ixon.Owned)
-  | inconsistentRegion (name : Lean.Name) (index : Nat)
-      (typeRegion bodyRegion : Option Nat)
-  | duplicateRegion (declaration region : Lean.Name)
-  | unknownRegion (declaration region : Lean.Name)
-  | conflictingRegions (declaration : Lean.Name)
+  | 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)
diff --git a/Ix/Compile/SourceContract/Elab.lean b/Ix/Compile/SourceContract/Elab.lean
index ae3732a41..c20ffdd9b 100644
--- a/Ix/Compile/SourceContract/Elab.lean
+++ b/Ix/Compile/SourceContract/Elab.lean
@@ -19,86 +19,202 @@ namespace Ix.Compile.SourceElab
 
 open Lean Elab Command Term
 
-/-- Lexical frontend context only. Each marker carries its complete parameter
-table, so imported source validation does not depend on this extension. -/
-meta initialize currentRegions : EnvExtension (Array Lean.Name) ← registerEnvExtension (pure #[])
-
-private meta def decodePrefix (modes : Syntax) : TermElabM (Ixon.Uses × Ixon.Owned × Option Lean.Name) := do
-  let parts := modes.getArgs.filter (!·.isNone)
-  for i in [1:parts.size] do
-    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 owned := if modes[0].isNone then Ixon.Owned.shared else .unique
-  let uses ← if modes[1].isNone then pure Ixon.Uses.many else do
-    let quantity := modes[1][0][0]
-    if quantity.isAtom && quantity.getAtomVal == "&" then pure .affine else
-      match quantity.isNatLit? with
-      | some 0 => pure .erased
-      | some 1 => pure .linear
-      | _ => throwErrorAt quantity "binder usage must be 0, 1, or &"
-  let region := if modes[2].isNone then none else some modes[2][0][1].getId
-  return (uses, owned, region)
-
--- Internal expansion target. The raw prefix and region table remain syntax
--- until Lean elaborates the corresponding binder domain.
-syntax (name := annotatedType) "__ix_binder% " num ident Ix.Compile.SourceSyntax.binderPrefix
-    "[" ident,* "]" "(" term ")" : 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 (uses, owned, region) ← decodePrefix stx[3]
-  let regions := stx[5].getSepArgs.map (·.getId)
-  if let some name := region then
-    unless regions.contains name do
-      throwErrorAt stx[3] "unbound region '{name}; introduce it with `regions '{name} in`"
+  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, owned, region, regions }
-  let type ← elabTerm stx[8] expectedType?
+    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 rewriteBinder (binder : Syntax) (origin : Nat) (regions : Array Lean.Name) :
-    CommandElabM Syntax := do
+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
-  unless kind == ``SourceSyntax.explicitBinder || kind == ``SourceSyntax.implicitBinder ||
-      kind == ``SourceSyntax.strictImplicitBinder || kind == ``SourceSyntax.instanceBinder do
-    return binder
+  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 modes : TSyntax ``Ix.Compile.SourceSyntax.binderPrefix := ⟨binder[1]⟩
-  let (_, _, region) ← liftTermElabM (decodePrefix modes.raw)
-  if let some region := region then
-    unless regions.contains region do
-      throwErrorAt modes "unbound region '{region}; introduce it with `regions '{region} in`"
-  let type : Term := ⟨binder[4]⟩
-  let origin : NumLit := ⟨Syntax.mkNumLit (toString origin)⟩
-  let regions := regions.map Lean.mkIdent
-  let marked ← `(__ix_binder% $origin:num $name:ident $modes:binderPrefix
-    [$[$regions:ident],*] ($type))
-  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
+  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 regions := currentRegions.getState (← getEnv)
-  let mut binders := #[]
-  for i in [:signature[0].getNumArgs] do
-    binders := binders.push (← rewriteBinder signature[0][i] i regions)
-  let signature := signature.setKind ``Parser.Command.optDeclSig |>.setArg 0 (mkNullNode binders)
+  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
@@ -113,19 +229,7 @@ meta def elabDeclaration : CommandElab := fun stx => do
       | .error error => throwErrorAt stx "{error}"
     setEnv env
 
-@[command_elab Ix.Compile.SourceSyntax.regions]
-meta def elabRegions : CommandElab := fun stx => do
-  let previous := currentRegions.getState (← getEnv)
-  let mut regions := previous
-  for parameter in stx[1].getArgs do
-    let name := parameter[1].getId
-    if regions.contains name then throwErrorAt parameter "duplicate region parameter '{name}"
-    regions := regions.push name
-  modifyEnv fun env => currentRegions.setState env regions
-  try
-    elabCommand stx[3]
-  finally
-    modifyEnv fun env => currentRegions.setState env previous
+attribute [command_parser 2000] Ix.Compile.SourceSyntax.declaration
 
 end Ix.Compile.SourceElab
 
diff --git a/Ix/Compile/SourceContract/Marker.lean b/Ix/Compile/SourceContract/Marker.lean
index ae6ba4cfc..94140bb5a 100644
--- a/Ix/Compile/SourceContract/Marker.lean
+++ b/Ix/Compile/SourceContract/Marker.lean
@@ -21,9 +21,9 @@ structure BinderAnnotation where
   origin : Nat
   binder : Lean.Name
   uses : Ixon.Uses
-  owned : Ixon.Owned
-  region : Option Lean.Name
-  regions : Array Lean.Name
+  value : Ixon.ValueContract
+  result : Option Ixon.ValueContract := none
+  letKind : Ixon.LetKind := .value
   deriving BEq, Repr, Inhabited
 
 def hasSourceAnnotation (data : Lean.MData) : Bool :=
@@ -31,15 +31,13 @@ def hasSourceAnnotation (data : Lean.MData) : Bool :=
 
 def BinderAnnotation.toMetadata (annotation : BinderAnnotation) : Lean.MData := Id.run do
   let mut data := ({} : Lean.MData)
-    |>.setNat sourceAnnotationKey 1
+    |>.setNat sourceAnnotationKey 3
     |>.setNat `ix.source.binder.origin annotation.origin
     |>.setName `ix.source.binder.name annotation.binder
-    |>.setNat `ix.source.binder.uses annotation.uses.toBits.toNat
-    |>.setNat `ix.source.binder.owned annotation.owned.toBits.toNat
-    |>.setSyntax `ix.source.binder.regions
-      (Lean.mkNullNode (annotation.regions.map fun name => (Lean.mkIdent name).raw))
-  if let some region := annotation.region then
-    data := data.setName `ix.source.binder.region region
+    |>.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
@@ -48,41 +46,37 @@ 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.uses, `ix.source.binder.owned, `ix.source.binder.regions,
-    `ix.source.binder.region]
+    `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 1) := data.find sourceAnnotationKey
+  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 uses) := data.find `ix.source.binder.uses
-    | throw "missing source binder usage"
-  if uses > 3 then throw "invalid source binder usage"
-  let some uses := Ixon.Uses.ofBits? uses.toUInt8
-    | throw "invalid source binder usage"
-  let some (.ofNat owned) := data.find `ix.source.binder.owned
-    | throw "missing source binder ownership"
-  if owned > 1 then throw "invalid source binder ownership"
-  let some owned := Ixon.Owned.ofBits? owned.toUInt8
-    | throw "invalid source binder ownership"
-  let some (.ofSyntax regions) := data.find `ix.source.binder.regions
-    | throw "missing source region parameters"
-  unless regions.isOfKind Lean.nullKind && regions.getArgs.all (·.isIdent) do
-    throw "invalid source region parameters"
-  let region ← match data.find `ix.source.binder.region with
+  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 (.ofName name) => pure (some name)
-    | _ => throw "invalid source region reference"
-  return some {
-    origin, binder, uses, owned, region
-    regions := regions.getArgs.map (·.getId) }
+    | 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)
diff --git a/Ix/Compile/SourceContract/Registry.lean b/Ix/Compile/SourceContract/Registry.lean
index e3e755ce3..d22e8820f 100644
--- a/Ix/Compile/SourceContract/Registry.lean
+++ b/Ix/Compile/SourceContract/Registry.lean
@@ -41,12 +41,10 @@ initialize sourceMeasureExtension :
 private def mergeContracts (actual : Lean.ConstantInfo) (patches : Array SourceContract) :
     Except SourceContractError SourceContract := do
   let mut binders := #[]
-  let regions := (patches[0]?.map (·.regions)).getD #[]
   for patch in patches do
     if patch.source != actual then throw (.staleSource patch.source.name)
-    if patch.regions != regions then throw (.conflictingRegions actual.name)
     binders := binders ++ patch.binders
-  return { source := actual, binders, regions }
+  return { source := actual, binders }
 
 /-- Register a checked patch. Disjoint patches accumulate; duplicate or
 conflicting occurrences fail even when their requested modes are identical. -/
@@ -80,6 +78,8 @@ def compileInputFromEnv (env : Lean.Environment)
   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
@@ -88,3 +88,4 @@ def compileInputFromEnv (env : Lean.Environment)
 end Ix.Compile
 
 end
+
diff --git a/Ix/Compile/SourceContract/Resolve.lean b/Ix/Compile/SourceContract/Resolve.lean
index 9d6735f71..18382928a 100644
--- a/Ix/Compile/SourceContract/Resolve.lean
+++ b/Ix/Compile/SourceContract/Resolve.lean
@@ -87,7 +87,7 @@ def resolveBinderSelector (source : Lean.ConstantInfo) (selector : BinderSelecto
 /-- 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) (regions : Array Lean.Name := #[]) :
+    (contracts : Array TelescopeContract) :
     Except SourceContractError SourceContract := do
   let types := sourceTelescope source .type
   let bodies := sourceTelescope source .body
@@ -97,61 +97,42 @@ def SourceContract.ofTelescope (source : Lean.ConstantInfo)
     let some (typeSite, _) := types[index]?
       | throw (.argumentOutOfRange source.name index)
     binders := binders.push {
-      site := typeSite, uses := contract.uses, resultOwned := contract.resultOwned
-      owned := contract.owned, region := contract.region }
+      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, owned := contract.owned, region := contract.region }
-  return { source, binders, regions }
+        site := bodySite, uses := contract.uses, value := contract.value, letKind := contract.letKind }
+  return { source, binders }
 
-def resolveBinderContract (source : Lean.ConstantInfo) (regions : Array Lean.Name)
-    (contract : BinderContract) :
+def resolveBinderContract (source : Lean.ConstantInfo) (contract : BinderContract) :
     Except SourceContractError ResolvedBinderContract := do
-  let region ← match contract.region with
-    | none => pure none
-    | some name => match regions.idxOf? name with
-      | some index => pure (some index)
-      | none => throw (.unknownRegion source.name name)
   let some expr := sourceAtSite? source contract.site
     | throw (.invalidSite source.name contract.site)
-  match expr with
-  | .lam name _ _ binderInfo =>
-    if contract.resultOwned.isSome then
-      throw (.ownershipOnLambda source.name contract.site)
-    return {
-      site := contract.site
-      kind := .lam
-      name := name
-      binderInfo := binderInfo
-      uses := contract.uses
-      resultOwned := none
-      owned := contract.owned
-      region }
-  | .forallE name _ _ binderInfo =>
-    return {
-      site := contract.site
-      kind := .all
-      name := name
-      binderInfo := binderInfo
-      uses := contract.uses
-      resultOwned := some (contract.resultOwned.getD .shared)
-      owned := contract.owned
-      region }
-  | _ => throw (.expectedBinder 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.ownedAt (contract : ResolvedSourceContract)
-    (site : BinderSite) : Ixon.Owned :=
-  ((contract.binders.find? fun binder => binder.site == site).map (·.owned)).getD .shared
-
-def ResolvedSourceContract.regionAt (contract : ResolvedSourceContract)
-    (site : BinderSite) : Option Nat :=
-  (contract.binders.find? fun binder => binder.site == site).bind (·.region)
+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) := #[]
@@ -163,11 +144,16 @@ private def collectAnnotations (declaration : Lean.Name) (root : SourceRoot)
   let site : BinderSite := ⟨root, path⟩
   let mut acc := acc
   match expr with
-  | .lam name type _ _ | .forallE name type _ _ =>
+  | .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
-        throw (.annotationBinderMismatch declaration site annotation.binder name)
+        -- 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)
@@ -202,16 +188,20 @@ def SourceContract.fromAnnotations (source : Lean.ConstantInfo) :
   let acc ← match sourceBody? source with
     | some body => collectAnnotations source.name .body body [] acc
     | none => pure acc
-  let regions := (acc.binders[0]?.map (·.2.regions)).getD #[]
   let mut origins : Std.HashSet (SourceRoot × Nat) := {}
   let mut binders := #[]
   for (site, annotation) in acc.binders do
-    if annotation.regions != regions then throw (.conflictingRegions source.name)
     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, owned := annotation.owned, region := annotation.region }
+      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
@@ -232,12 +222,12 @@ def SourceContract.fromAnnotations (source : Lean.ConstantInfo) :
           | throw (.expectedBinder source.name typeSite)
         let some (.lam bodyName bodyDomain _ bodyInfo) := sourceAtSite? source bodySite
           | throw (.expectedBinder source.name bodySite)
-        if typeName != bodyName || typeInfo != bodyInfo ||
+        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, resultOwned := none }
-  return { source, binders, regions }
+          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.
@@ -255,14 +245,10 @@ def checkTelescopeConsistency (contract : ResolvedSourceContract) :
       let bodyUses := contract.usesAt bodySite
       if typeUses != bodyUses then
         throw (.inconsistentTelescope contract.source.name index typeUses bodyUses)
-      let typeOwned := contract.ownedAt typeSite
-      let bodyOwned := contract.ownedAt bodySite
-      if typeOwned != bodyOwned then
-        throw (.inconsistentOwnership contract.source.name index typeOwned bodyOwned)
-      let typeRegion := contract.regionAt typeSite
-      let bodyRegion := contract.regionAt bodySite
-      if typeRegion != bodyRegion then
-        throw (.inconsistentRegion contract.source.name index typeRegion bodyRegion)
+      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)
@@ -277,25 +263,19 @@ def SourceContract.resolve (contract : SourceContract) (actual : Lean.ConstantIn
   if contract.source != actual then throw (.staleSource contract.source.name)
   if sourceHasAnnotations actual then
     let expected ← SourceContract.fromAnnotations actual
-    if expected.regions != contract.regions then throw (.conflictingRegions actual.name)
     for annotation in expected.binders do
       let some supplied := contract.binders.find? (·.site == annotation.site)
         | throw (.missingAnnotation actual.name annotation.site)
-      if supplied.uses != annotation.uses || supplied.owned != annotation.owned ||
-          supplied.region != annotation.region then
+      if supplied != annotation then
         throw (.conflictingAnnotation actual.name annotation.site)
-  let mut seenRegions : Std.HashSet Lean.Name := {}
-  for region in contract.regions do
-    if seenRegions.contains region then throw (.duplicateRegion actual.name region)
-    seenRegions := seenRegions.insert region
   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 contract.regions binder)
+    binders := binders.push (← resolveBinderContract actual binder)
   binders := binders.qsort fun a b => compare a.site b.site == .lt
-  let result : ResolvedSourceContract := { source := actual, binders, regions := contract.regions }
+  let result : ResolvedSourceContract := { source := actual, binders }
   checkTelescopeConsistency result
   return result
 
diff --git a/Ix/Compile/SourceContract/Syntax.lean b/Ix/Compile/SourceContract/Syntax.lean
index 986ccb00d..c5d87da73 100644
--- a/Ix/Compile/SourceContract/Syntax.lean
+++ b/Ix/Compile/SourceContract/Syntax.lean
@@ -6,8 +6,7 @@ public import Lean
 # Binder-prefix grammar
 
 The declaration parser activates only when a header has an annotated binder.
-Region names use a contextual raw apostrophe, leaving Lean character literals
-unchanged. The elaborator is loaded by importing SourceContract.Elab.
+The elaborator is loaded by importing SourceContract.Elab.
 -/
 
 public meta section
@@ -16,15 +15,10 @@ namespace Ix.Compile.SourceSyntax
 
 open Lean Parser
 
-@[expose] def regionName := leading_parser rawCh '\'' >> ident
+@[expose] def prefixAtom := leading_parser
+  rawCh '!' (trailingWs := true) <|> rawCh '~' (trailingWs := true) <|> numLit <|> "&"
 
-@[expose] def quantity := leading_parser numLit <|> "&"
-
-@[expose] def binderPrefix := leading_parser
-  lookahead (regionName <|> rawCh '!' <|> quantity) >>
-  optional (rawCh '!' (trailingWs := true)) >>
-  optional (notFollowedBy (rawCh '\'') "region name" >> quantity) >>
-  optional regionName
+@[expose] def binderPrefix := leading_parser many1 prefixAtom
 
 @[expose] def explicitBinder := leading_parser
   "(" >> binderPrefix >> checkWsBefore "space required before the binder name" >>
@@ -46,8 +40,16 @@ open Lean Parser
 @[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 >> (annotatedBinder <|> Term.bracketedBinder <|> Term.binderIdent)) >> Term.optType
+  many (ppSpace >> (atomic annotatedBinder <|> Term.bracketedBinder <|> Term.binderIdent)) >>
+    (atomic resultType <|> Term.optType)
 
 @[expose] def hasAnnotatedBinder (signature : Syntax) : Bool :=
   signature[0].getArgs.any fun binder =>
@@ -56,16 +58,56 @@ open Lean Parser
 
 @[expose] def definition := leading_parser
   "def " >> Command.declId >> ppIndent declarationSignature >>
-  checkStackTop hasAnnotatedBinder "annotated binder" >>
   Command.declVal >> Command.optDefDeriving
 
 @[expose] def declaration := leading_parser Command.declModifiers false >> definition
 
-@[expose] def regions := leading_parser
-  nonReservedSymbol "regions" (includeIdent := true) >>
-  many1 (ppSpace >> regionName) >> " in " >> commandParser
+@[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
 
-attribute [command_parser 2000] declaration regions
+@[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
 
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 1779c7717..827668ce3 100644
--- a/Ix/CompileDriver.lean
+++ b/Ix/CompileDriver.lean
@@ -40,7 +40,8 @@ public import Ix.CanonM
 public import Ix.Ground
 public import Ix.CompileM
 public import Ix.AuxGen.CompileAux
-public import Ix.Compile.SourceContract
+public import Ix.Compile.SourceContract.Transport
+public import Ix.Resource.Validate
 public section
 
 namespace Ix.CompileM
@@ -1019,13 +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!"source binder contracts are not supported by this compiler yet: {name}"
+      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
@@ -1146,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 =>
@@ -1159,19 +1184,45 @@ def compileLeanConsts (consts : List (Lean.Name × Lean.ConstantInfo))
         blockCount := condensed.blocks.size
         digests }
 
-/-- Explicit frontend boundary. Contract resolution runs before compilation.
-The current production emitter accepts only ordinary source; semantic contracts
-are rejected until transport through canonicalization and rewriting is complete.
-Optional measure proposals do not alter ordinary output. -/
+/-- 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) :
+    (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 resolved ← match input.resolve with
-    | .ok resolved => pure resolved
+  let input ← match Ix.Compile.CompileInput.fromAnnotations consts with
+    | .ok input => pure input
     | .error error => return .error (toString error)
-  if let some contract := resolved.contracts[0]? then
-    return .error s!"source binder contracts are not supported by this compiler yet: {contract.source.name}"
-  compileLeanConsts resolved.constants rustRef numWorkers dbg
+  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/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 0000000000000000000000000000000000000000..07c83f03c23ec31e1204d5098096c71f0dba8626
GIT binary patch
literal 350
zcmaF-;bq}ZtLMvC@$YZHFSf`f>hJE}&O1B`lYMrst7M$ol*z!rz@q)nB-QZKoaNKa
zPA}V$_r~pztNgWZCr-RAh+uWxBP@H$=mI0dL|X+01%^gm1%?fb0*sHNHWo+xdcH#L
zx9yaLDSz!-S9kMtbgg2S`Nx~^e~-)>hVyS&FJAu?sGnMX=$ljvt8#;n*%cNWRjn<%
zR5{*04=fZu$OyEVfdN7qfLVkLRlP>gSfDvy_Gr!PQ|sFt^j$Kwwu5a$(bCXG^YwPb
z6*a`)J$aUKqS_S(VvJ#6)U~>I|D$x`N1u*7)Ab9?igVAlFZWg7dN7bl^}^RlkA#7C
F0RXz0m`MNt

literal 0
HcmV?d00001

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 0000000000000000000000000000000000000000..213d5e6e37bfc0ce708ba4d1564be4814a1630c2
GIT binary patch
literal 40
rcmd0-$j{R)GuAIkEzU13N>0@+Gt@6A%1_J8No4?oMh3>F1#OG~8E*_r

literal 0
HcmV?d00001

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 0000000000000000000000000000000000000000..e073192ef1ec7ea78710e5d008d2a720c4422168
GIT binary patch
literal 350
zcmaF7Rcq%@=8%|0p?CXPeKz&_pHA0*6}8zSty!d9S*z9aJOcv*%lS8~7q5Q`)K4ux
z^i8UTRk^{(><WvGs@9fWsvK{h2Nnt+WCSW>V1SSYVAkWPjl~hap0AMmZ98RQ%3u4|
z)!jTDU8~q-{_!UK-y^d|^%?^qV}a&8zpKF*T6sb-^HMA89AV+KD|Vifez#^W@Yu2=
zq48+6qR|CLhKaHY3<?a5yb25(7zG#!*~{={kJh|CwZ6?k-z8IPJJ>c9Ee%~XUvEcT
zQA7OQlV=$xs$F3q#$^nQx>on@f0R!A=+lvBx_*IKaqijn<-Y1$4+b)+UidockucEt
E09-tiL;wH)

literal 0
HcmV?d00001

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..30210975d
--- /dev/null
+++ b/Tests/Ix/IxonV3.lean
@@ -0,0 +1,117 @@
+module
+public import Ix.Ixon
+public import Ix.Sharing
+
+public section
+
+namespace Tests.IxonV3
+open Ixon
+
+def fixtures : List (String × Expr) := [
+  ("app", .app (.app (.app (.var 3) (.var 2)) (.var 1)) (.var 0)),
+  ("lam", .lam .many (.sort 0) (.lam .many (.sort 0) (.lam .many (.sort 0) (.var 0)))),
+  ("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 (String × Expr × ByteArray) := 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
+
+def modeFixtures : List (String × Expr) := modeCases.map fun (label, expr, _) => (label, expr)
+
+def parseHex : List Char → Except String (List UInt8)
+  | [] => .ok []
+  | hi :: lo :: rest => do
+    let some hi := natOfHex hi | throw "invalid hex digit"
+    let some lo := natOfHex lo | throw "invalid hex digit"
+    return (hi * 16 + lo).toUInt8 :: (← parseHex rest)
+  | _ => .error "odd hex length"
+
+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 malformed : Array ByteArray := (#[] : Array ByteArray) ++ #[
+  .mk #[0x70], .mk #[0x80], .mk #[0x90],
+  .mk #[0x71, 0x71, 0x10, 0x11, 0x12],
+  .mk #[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10],
+  .mk #[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10],
+  .mk #[0xA4, 0x07, 0x00, 0x10, 0x10],
+  .mk #[0x18, 0x00], .mk #[0x28, 0x07, 0x00], .mk #[0x20, 0x80, 0x00],
+  .mk #[0x87, 0x07, 0x00, 0x10], .mk #[0x77, 0x10]
+]
+
+def runGolden : IO Nat := do
+  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/expressions.txt"
+  let mut checks := 0
+  for (name, expr) in fixtures do
+    let some line := (file.splitOn "\n").find? (·.startsWith (name ++ " "))
+      | throw <| IO.userError s!"missing fixture {name}"
+    let some hex := (line.splitOn " ")[1]?
+      | throw <| IO.userError s!"missing bytes for {name}"
+    let expected ← match parseHex hex.toList with
+      | .ok bytes => pure (ByteArray.mk bytes.toArray)
+      | .error e => throw <| IO.userError e
+    checks := checks + (← checkBytes name expr expected)
+  for (name, expr, expected) in modeCases do
+    checks := checks + (← checkBytes name expr expected)
+  for bytes in malformed do
+    if (runGetExact getExpr bytes).toOption.isSome then
+      throw <| IO.userError s!"accepted noncanonical bytes {hexOfBytes bytes}"
+    checks := checks + 1
+  for code in [16:256] do
+    for bytes in #[ByteArray.mk #[0x81, code.toUInt8, 0x00, 0x10],
+        ByteArray.mk #[0xA0, code.toUInt8, 0x00, 0x10, 0x10]] do
+      if (runGetExact getExpr bytes).toOption.isSome then
+        throw <| IO.userError s!"accepted reserved contract bits {code}"
+      checks := checks + 1
+  for code in [64:256] do
+    if (runGetExact getExpr (.mk #[0x91, code.toUInt8, 0x00, 0x10])).toOption.isSome then
+      throw <| IO.userError s!"accepted reserved forall bits {code}"
+    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..b063a22f2
--- /dev/null
+++ b/Tests/Ix/IxonV3FFI.lean
@@ -0,0 +1,42 @@
+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 : IO Nat := do
+  let mut checks := 0
+  for (name, expr) in fixtures ++ modeFixtures 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 := (fixtures[1]!).2
+  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 ConstantInfo := #[
+    .defn defn, .recr recr, .axio ⟨true, 5, typ⟩,
+    .quot ⟨.lift, 5, typ⟩, .muts #[.defn defn, .indc ind, .recr recr]]
+  for info in infos do
+    let c : Constant := ⟨info, #[value], #[], #[.zero]⟩
+    unless roundtripConstant c == c do
+      throw <| IO.userError "declaration FFI roundtrip differs"
+    unless equalConstantBytes c (serConstant c) do
+      throw <| IO.userError "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..a2986475c
--- /dev/null
+++ b/Tests/Ix/IxonV3VM.lean
@@ -0,0 +1,257 @@
+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)
+
+def checkVMBytes (env : AiurTestEnv) (name : String) (bytes : ByteArray)
+    (accept : Bool) (fnName : Lean.Name := `ixon_expr_codec) : IO Nat := do
+  let some index := env.compiled.getFuncIdx fnName
+    | throw <| IO.userError "missing VM codec entrypoint"
+  let buffer := codecBuffer bytes
+  let executed := env.compiled.bytecode.execute index #[] buffer
+  match executed with
+  | .ok (out, io, _) =>
+    unless accept && out.isEmpty && io == buffer do
+      throw <| IO.userError s!"{name}: VM unexpectedly accepted or changed output"
+  | .error e =>
+    if accept then throw <| IO.userError s!"{name}: VM execution failed: {e}"
+  let (interpreted, state) := Aiur.runFunction env.decls (.mk fnName) [] 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!"{name}: source interpretation unexpectedly accepted or changed output"
+  | .error e =>
+    if accept then throw <| IO.userError s!"{name}: source interpretation failed: {e}"
+  return 2
+
+/-- 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 := do
+  let index := env.compiled.getFuncIdx witness.funcName |>.get!
+  let executed := env.compiled.bytecode.execute index witness.input witness.inputIOBuffer
+  match executed with
+  | .ok (out, io, _) =>
+    unless accept && out.isEmpty && io == witness.inputIOBuffer do
+      throw <| IO.userError s!"{label}: VM claim unexpectedly accepted or changed output"
+  | .error e =>
+    if accept then throw <| IO.userError s!"{label}: VM claim execution failed: {e}"
+  match env.compiled.bytecode.executeIxVM index witness.input witness.inputIOBuffer with
+  | .ok (out, io, counts) =>
+    let .ok (expectedOut, expectedIO, expectedCounts) := executed
+      | throw <| IO.userError s!"{label}: generated VM accepted a rejected claim"
+    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 claim execution failed: {e}"
+  let name := Aiur.Global.mk witness.funcName
+  let inputTypes := match env.decls.getByKey name with
+    | some (.function f) => f.inputs.map (·.2)
+    | _ => []
+  let inputs := Aiur.unflattenInputs env.decls witness.input inputTypes
+  match Aiur.runFunction env.decls name inputs witness.inputIOBuffer with
+  | (.ok _, state) =>
+    unless accept && state.ioBuffer == witness.inputIOBuffer do
+      throw <| IO.userError s!"{label}: claim interpreter unexpectedly accepted"
+  | (.error e, _) =>
+    if accept then throw <| IO.userError s!"{label}: claim interpretation failed: {e}"
+  return 3
+
+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, target) := Tests.ResourceAddressed.store base constant
+  let env := { env with anonHints := env.anonHints.insert target .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
+  for claim in [Ix.Claim.check target none, .checkEnv tree.root none,
+      .reveal target (.defn none none none
+        (some (Address.blake3 (Ixon.runPut (Ixon.putExpr
+          (.all Tests.ResourceAddressed.linearLocal .localShared (.ref 0 #[]) (.ref 0 #[])))))) none),
+      .contains tree.root target] do
+    let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env claim trees)
+    checks := checks + (← checkVMClaim vm "v3 claim" witness true)
+    let bytes := Ix.Claim.ser claim
+    for bad in [bytes.push 0, bytes.set! 1 2, bytes.set! 2 255,
+        bytes.extract 0 (bytes.size - 1)] do
+      checks := checks + (← checkVMClaim vm "invalid v3 claim"
+        (replaceClaimBytes witness bad) false)
+  -- Erased typing deliberately accepts a resource-invalid body. The
+  -- validator byte keeps that fact separate from resource admission.
+  let (escaping, target) := Tests.ResourceAddressed.store base
+    (Tests.ResourceAddressed.identity unit Tests.ResourceAddressed.linearLocal .shared)
+  let escaping := { escaping with anonHints := escaping.anonHints.insert target .opaque }
+  let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness escaping (.check target 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)
+  -- The positive proof uses the valid annotated target from the original env.
+  let validTarget := Tests.ResourceAddressed.store base constant |>.2
+  let checkWitness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env (.check validTarget none))
+  let index := vm.compiled.getFuncIdx checkWitness.funcName |>.get!
+  let (claim, proof, _) ← IO.ofExcept
+    (vm.aiurSystem.prove index checkWitness.input checkWitness.inputIOBuffer)
+  IO.ofExcept (vm.aiurSystem.verify claim (Aiur.Proof.ofBytes proof.toBytes))
+  return checks + 1
+
+def runVM : IO Nat := do
+  let env ← IO.ofExcept (AiurTestEnv.build codecToplevel)
+  let mut checks := 0
+  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/expressions.txt"
+  let mut cases := modeCases.map fun (name, _, bytes) => (name, bytes)
+  for (name, _) in fixtures do
+    let some line := (file.splitOn "\n").find? (·.startsWith (name ++ " "))
+      | throw <| IO.userError s!"missing fixture {name}"
+    let some hex := (line.splitOn " ")[1]?
+      | throw <| IO.userError s!"missing fixture bytes {name}"
+    let bytes ← IO.ofExcept (parseHex hex.toList)
+    cases := cases ++ [(name, ByteArray.mk bytes.toArray)]
+  for (name, bytes) in cases do
+    checks := checks + (← checkVMBytes env name bytes true)
+    checks := checks + (← checkVMBytes env s!"{name}-trailing" (bytes.push 0) false)
+    for n in [:bytes.size] do
+      checks := checks + (← checkVMBytes env s!"{name}-truncated-{n}" (bytes.extract 0 n) false)
+  for bytes in malformed do
+    checks := checks + (← checkVMBytes env "malformed" bytes false)
+  checks := checks + (← runCountTruncations env)
+  for code in [16:256] do
+    for bytes in #[ByteArray.mk #[0x81, code.toUInt8, 0x00, 0x10],
+        ByteArray.mk #[0xA0, code.toUInt8, 0x00, 0x10, 0x10]] do
+      checks := checks + (← checkVMBytes env "reserved-binder-bits" bytes false)
+  for code in [64:256] do
+    checks := checks + (← checkVMBytes env "reserved-forall-bits"
+      (.mk #[0x91, code.toUInt8, 0x00, 0x10]) false)
+  -- Independently authored declaration bytes cover the six unchanged headers.
+  for hex in [
+      "d006050010000000",
+      "d101050102030400010310000000",
+      "d2010500000000",
+      "d3020500000000",
+      "c101000502030001010501020300000000"] do
+    let bytes ← IO.ofExcept (parseHex hex.toList)
+    let bytes := ByteArray.mk bytes.toArray
+    checks := checks + (← checkVMBytes env "declaration" bytes true `ixon_const_codec)
+    checks := checks + (← checkVMBytes env "declaration-trailing" (bytes.push 0) false `ixon_const_codec)
+    for n in [:bytes.size] do
+      checks := checks + (← checkVMBytes env "declaration-truncated" (bytes.extract 0 n) false `ixon_const_codec)
+  -- Exercise the proof pipeline for an explicit scoped-borrow representation.
+  let bytes := ByteArray.mk #[0xA2, 0x0e, 0x00, 0x41, 0x02, 0x11, 0x10]
+  let index := env.compiled.getFuncIdx `ixon_expr_codec |>.get!
+  let (claim, proof, _) ← IO.ofExcept (env.aiurSystem.prove index #[] (codecBuffer bytes))
+  let proof := Aiur.Proof.ofBytes proof.toBytes
+  IO.ofExcept (env.aiurSystem.verify claim proof)
+  -- 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..f217d2226
--- /dev/null
+++ b/Tests/Ix/Resource.lean
@@ -0,0 +1,285 @@
+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 := #[
+  ⟨"ordinary identity", arr (b .many), lam (b .many) (v 0), "ok"⟩,
+  ⟨"linear identity", arr (b .linear), lam (b .linear) (v 0), "ok"⟩,
+  ⟨"linear unique transfer", arr (b .linear .unique) .unique,
+    lam (b .linear .unique) (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"⟩,
+  ⟨"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"⟩,
+  ⟨"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"⟩,
+  ⟨"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"⟩,
+  ⟨"unregistered projection has no optimistic rule", arr (b .many .unique),
+    lam (b .many .unique) (.prj 0 0 (v 0)), "unsupported"⟩,
+  ⟨"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"⟩,
+  ⟨"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"⟩,
+  ⟨"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"⟩,
+  ⟨"fresh inner linear binder under many demand", arr (b .many),
+    lam (b .many) (call 5 (bind (b .linear) (v 0) (v 0))), "ok"⟩,
+  ⟨"discarding borrow before narrowing fresh result", arr (b .many .unique) .localShared,
+    lam (b .many .unique) (borrow (v 0) (call 1 (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"⟩,
+  ⟨"selection cannot bypass its rule through a callback", arr (b .many) .shared natTy (choiceType .shared),
+    lam (b .many) (ref 6), "unsupported"⟩,
+  ⟨"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"⟩,
+  ⟨"branch analysis follows a shared application head", arr (b .linear),
+    lam (b .linear) (.app (.app (.app (.share 1) zero) (v 0)) (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"⟩,
+  ⟨"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"⟩,
+  ⟨"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"⟩
+]
+
+def additionalCases : 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 ++ additionalCases
+
+def run : IO Unit := do
+  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/resource.tsv"
+  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 (file.splitOn "\n").contains line do
+      throw <| IO.userError s!"resource fixture bytes differ: {test.name}"
+  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}"
+  -- Budget exhaustion is an error, including cycles through open sharing.
+  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"
+  IO.println s!"Resource checker: {allCases.size + 65} 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
index 0fbdcc56a..1e9255c4b 100644
--- a/Tests/Ix/SourceContract.lean
+++ b/Tests/Ix/SourceContract.lean
@@ -40,20 +40,20 @@ private def expectError (actual : Except SourceContractError α) (expected : Sou
   | .ok _ => false
 
 private def resolvedModes (actual : Except SourceContractError ResolvedSourceContract) :
-    Array (BinderSite × Ixon.Uses × Option Ixon.Owned) :=
+    Array (BinderSite × Ixon.Uses × Option Ixon.ValueContract) :=
   match actual with
   | .error _ => #[]
-  | .ok contract => contract.binders.map fun binder => (binder.site, binder.uses, binder.resultOwned)
+  | .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, resultOwned := some .unique }]) ==
+    (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, resultOwned := some .shared }]).isOk) ++
+      (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, resultOwned := some .unique }]) ==
+    (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"
@@ -98,7 +98,7 @@ def occurrenceTests : TestSeq := Id.run do
     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, resultOwned := some .unique }]) ==
+      (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"
@@ -125,8 +125,8 @@ def rejectionTests : TestSeq := Id.run do
       (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, resultOwned := some .shared }] } : SourceContract).resolve identity)
-        (.ownershipOnLambda `identity bodySite)) ++
+      (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"
@@ -186,53 +186,55 @@ def inputTests : TestSeq := Id.run do
       (expectError (({ hinted with measureHints := hinted.measureHints ++ hinted.measureHints }).resolve)
         (.duplicateMeasure `identity))
 
-def ownershipRegionTests : TestSeq := Id.run do
+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, owned := .unique }
-  let regional (name : Name) : TelescopeContract :=
-    { unique with uses := .affine, region := some name }
-  let resolveRegion (names : Array Name) (name : Name) := do
-    (← SourceContract.ofTelescope source #[regional name] names).resolve source
+  let unique : TelescopeContract := { binder := .position 0, uses := .many, value := .unique }
   let ownershipMismatch : SourceContract := {
-    source, binders := #[{ site := typeSite, uses := .many, owned := .unique }] }
-  let regionMismatch : SourceContract := {
-    source, regions := #[`a],
-    binders := #[{ site := typeSite, uses := .many, region := some `a }] }
-  return test "unique binder ownership is independent of arrow-result ownership"
+    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.ownedAt typeSite == .unique && result.ownedAt bodySite == .unique &&
+        | .ok result => result.valueAt typeSite == .unique && result.valueAt bodySite == .unique &&
           result.usesAt typeSite == .many &&
-          (result.binders.find? (·.site == typeSite)).bind (·.resultOwned) == some .shared
+          (result.binders.find? (·.site == typeSite)).bind (·.result) == some .shared
         | .error _ => false) ++
-    test "binder ownership composes with all four usages without claiming validity"
-      ([Ixon.Uses.erased, .linear, .affine, .many].all fun uses =>
-        (resolveTelescope source #[{ unique with uses }]).isOk) ++
-    test "region parameters resolve to declaration-local indices on both roots"
-      (match resolveRegion #[`b, `a] `a with
-        | .ok result => result.regionAt typeSite == some 1 && result.regionAt bodySite == some 1 &&
-          result.ownedAt bodySite == .unique && result.usesAt bodySite == .affine
+    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 "renaming a bound region preserves all resolved assertions"
-      (match resolveRegion #[`a] `a, resolveRegion #[`renamed] `renamed with
-        | .ok first, .ok second => first.semantics == second.semantics
-        | _, _ => false) ++
-    test "unbound region names are rejected"
-      (expectError (resolveRegion #[`a] `missing) (.unknownRegion `identity `missing)) ++
-    test "duplicate region parameters are rejected"
-      (expectError (resolveRegion #[`a, `a] `a) (.duplicateRegion `identity `a)) ++
-    test "type and body must agree on binder ownership"
+    test "type and body must agree on ownership"
       (expectError (ownershipMismatch.resolve source)
-        (.inconsistentOwnership `identity 0 .unique .shared)) ++
-    test "type and body must agree on the region bound"
-      (expectError (regionMismatch.resolve source)
-        (.inconsistentRegion `identity 0 (some 0) none))
+        (.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, owned := .unique
-    region := some `a, regions := #[`a] }
+    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 }
@@ -247,7 +249,7 @@ def markerTests : TestSeq := Id.run do
     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, region, and origin"
+  return test "source annotation metadata roundtrips ownership, usage, locality, and origin"
       (match BinderAnnotation.ofMetadata? data with
         | .ok decoded => decoded == some annotation
         | .error _ => false) ++
@@ -276,13 +278,13 @@ def markerTests : TestSeq := Id.run do
         match SourceContract.fromAnnotations marked with
         | .ok contract =>
           let changed : SourceContract := { contract with
-            binders := contract.binders.map fun binder => { binder with owned := .shared } }
+            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, ownershipRegionTests, markerTests]
+  [telescopeTests, occurrenceTests, rejectionTests, inputTests, valueContractTests, markerTests]
 
 end Tests.Ix.SourceContract
 
diff --git a/Tests/Ix/SourceContract/Driver.lean b/Tests/Ix/SourceContract/Driver.lean
index ef20868ff..8a2af8c6d 100644
--- a/Tests/Ix/SourceContract/Driver.lean
+++ b/Tests/Ix/SourceContract/Driver.lean
@@ -15,8 +15,7 @@ private def plainSource : ConstantInfo := .axiomInfo {
   isUnsafe := false }
 
 private def annotation : BinderAnnotation := {
-  origin := 0, binder := `x, uses := .affine, owned := .unique
-  region := some `a, regions := #[`a] }
+  origin := 0, binder := `x, uses := .affine, value := .localUnique }
 
 private def markedSource : ConstantInfo := .axiomInfo {
   name := plainSource.name, levelParams := []
@@ -30,17 +29,17 @@ private def ioTest (description : String) (check : IO Bool) : TestSeq :=
 
 private def unsupported (result : Except String α) : Bool :=
   match result with
-  | .error message => message.startsWith "source binder contracts are not supported"
+  | .error message => (message.splitOn "external resource interface is absent").length > 1
   | .ok _ => false
 
 def suite : List TestSeq := [
-  ioTest "Lean constant-list driver rejects source markers before canonicalization" do
+  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 validates and rejects unsupported out-of-band contracts" do
+  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
@@ -61,7 +60,7 @@ def suite : List TestSeq := [
           let _ ← rsCompileEnvBytesFFI (constants markedSource) output.toString allowPartial
           pure false
         catch error =>
-          pure ((error.toString.splitOn "source binder contracts are not supported").length > 1)
+          pure ((error.toString.splitOn "unresolved source binder contracts").length > 1)
         if !rejected || (← output.pathExists) ||
             (← (System.FilePath.mk (output.toString ++ ".tmp")).pathExists) then
           return false
@@ -73,3 +72,4 @@ def suite : List TestSeq := [
 end Tests.Ix.SourceContract.Driver
 
 end
+
diff --git a/Tests/Ix/SourceContract/ImportCheck.lean b/Tests/Ix/SourceContract/ImportCheck.lean
index 19e2bf635..2c3dfec18 100644
--- a/Tests/Ix/SourceContract/ImportCheck.lean
+++ b/Tests/Ix/SourceContract/ImportCheck.lean
@@ -21,7 +21,7 @@ run_cmd do
     | 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 (·.resultOwned) == some .unique do
+  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
diff --git a/Tests/Ix/SourceContract/Imported.lean b/Tests/Ix/SourceContract/Imported.lean
index c7a8d92c9..ff900bdda 100644
--- a/Tests/Ix/SourceContract/Imported.lean
+++ b/Tests/Ix/SourceContract/Imported.lean
@@ -17,7 +17,7 @@ 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, resultOwned := some .unique }]
+  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"
diff --git a/Tests/Ix/SourceContract/SyntaxCheck.lean b/Tests/Ix/SourceContract/SyntaxCheck.lean
index 0781aeaef..03c74cb73 100644
--- a/Tests/Ix/SourceContract/SyntaxCheck.lean
+++ b/Tests/Ix/SourceContract/SyntaxCheck.lean
@@ -15,11 +15,21 @@ run_cmd do
     ``Tests.Ix.SourceContract.SyntaxFixture.strictImplicit,
     ``Tests.Ix.SourceContract.SyntaxFixture.shadowed,
     ``Tests.Ix.SourceContract.SyntaxFixture.nativeBorrow,
-    ``Tests.Ix.SourceContract.SyntaxFixture.twoRegions,
-    ``Tests.Ix.SourceContract.SyntaxFixture.renamedRegion,
-    ``Tests.Ix.SourceContract.SyntaxFixture.renamedTwoRegions,
-    ``Tests.Ix.SourceContract.SyntaxFixture.unrestrictedRegion,
-    ``Tests.Ix.SourceContract.SyntaxFixture.uniqueRegion]
+    ``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
@@ -35,32 +45,31 @@ run_cmd do
       | throwError "missing syntax contract {name}"
     pure contract
   let unique ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.unique
-  unless unique.ownedAt ⟨.type, []⟩ == .unique && unique.ownedAt ⟨.body, []⟩ == .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 (·.resultOwned) == some .shared do
+  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.ownedAt ⟨.type, []⟩ == .unique &&
-      native.regionAt ⟨.type, []⟩ == some 0 && native.regionAt ⟨.body, []⟩ == some 0 do
-    throwError "combined ownership, usage, and region changed on import"
+  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.twoRegions
-  unless pair.regionAt ⟨.type, []⟩ == some 0 &&
-      pair.regionAt ⟨.type, [.binderBody]⟩ == some 1 do
-    throwError "distinct region parameters were conflated"
-  let renamed ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.renamedRegion
+  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 "region renaming changed the resolved assertions"
-  let renamedPair ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.renamedTwoRegions
+    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 region and term binders changed the resolved assertions"
-  let unrestricted ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.unrestrictedRegion
+    throwError "renaming multiple term binders changed the resolved assertions"
+  let unrestricted ← getContract ``Tests.Ix.SourceContract.SyntaxFixture.localShared
   unless unrestricted.usesAt ⟨.body, []⟩ == .many &&
-      unrestricted.ownedAt ⟨.body, []⟩ == .shared &&
-      unrestricted.regionAt ⟨.body, []⟩ == some 0 do
-    throwError "region-only prefix changed usage or ownership defaults"
+      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
@@ -77,6 +86,50 @@ run_cmd do
   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"
@@ -96,15 +149,6 @@ run_cmd do
     if (Parser.runParserCategory (← getEnv) `command text).isOk then
       throwError "invalid binder spelling was accepted: {text}"
 
-/-- error: unbound region 'a; introduce it with `regions 'a in` -/
-#guard_msgs in
-def unboundRegion (&'a x : Nat) : Nat := x
-
-/-- error: duplicate region parameter 'a -/
-#guard_msgs in
-regions 'a 'a in
-def duplicateRegions (&'a x : Nat) : Nat := x
-
 /-- error: binder usage must be 0, 1, or & -/
 #guard_msgs in
 def invalidQuantity (2 x : Nat) : Nat := x
@@ -113,7 +157,26 @@ def invalidQuantity (2 x : Nat) : Nat := x
 #guard_msgs in
 def separatedPrefix (! & x : Nat) : Nat := x
 
--- A previous `regions ... in` command must not leak to later declarations.
-/-- error: unbound region 'a; introduce it with `regions 'a in` -/
+/-- 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 escapedRegionParameter (!&'a x : Nat) : Nat := x
+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
index b999568e8..3476dac28 100644
--- a/Tests/Ix/SourceContract/SyntaxFixture.lean
+++ b/Tests/Ix/SourceContract/SyntaxFixture.lean
@@ -19,26 +19,35 @@ def withInstance {0 α : Type} [& inst : Inhabited α] : α := default
 def strictImplicit ⦃0 α : Type⦄ (1 x : α) : α := x
 def shadowed (1 _x : Nat) (& _x : Nat) : Nat := _x
 
-regions 'a in
-def nativeBorrow (!&'a x : @& Nat) : Nat := x
+def nativeBorrow (~!& x : @& Nat) : Nat := x
 
-regions 'a 'b in
-def twoRegions (!&'a x : Nat) (1'b y : Nat) : Nat := x + y
+def twoLocal (~!& x : Nat) (1~ y : Nat) : Nat := x + y
 
-regions 'renamed in
-def renamedRegion (!&'renamed value : Nat) : Nat := value
+def renamedLocal (~!& value : Nat) : Nat := value
 
-regions 'left 'right in
-def renamedTwoRegions (!&'left first : Nat) (1'right second : Nat) : Nat := first + second
+def renamedTwoLocal (~!& first : Nat) (1~ second : Nat) : Nat := first + second
 
-regions 'a in
-def unrestrictedRegion ('a x : Nat) : Nat := x
+def localShared (~ x : Nat) : Nat := x
 
-regions 'a in
-def uniqueRegion (!'a 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.
@@ -54,7 +63,7 @@ run_cmd do
   | .error error => Lean.throwError m!"{error}"
 
 example : linear 3 = 3 := rfl
-example : twoRegions 2 5 = 7 := rfl
+example : twoLocal 2 5 = 7 := rfl
 example : privateIdentity 4 = 4 := rfl
 example : ordinaryChar = 'a' := rfl
 
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..77a5cd94a
--- /dev/null
+++ b/Tests/IxonV3Main.lean
@@ -0,0 +1,52 @@
+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 checks ← Tests.IxonV3.runGolden
+  IO.println s!"Ixon v3: {checks} golden byte and rejection checks passed"
+  let ffiChecks ← Tests.IxonV3.runFFI
+  IO.println s!"Ixon v3: {ffiChecks} FFI, byte parity, and sharing hash checks passed"
+  let vmChecks ← Tests.IxonV3.runVM
+  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 d02d05ea0..a33b64044 100644
--- a/Tests/Main.lean
+++ b/Tests/Main.lean
@@ -233,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
@@ -257,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.
@@ -269,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)
@@ -279,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/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 af9b67f7c..2f3146f09 100644
--- a/crates/compile/src/compile/env.rs
+++ b/crates/compile/src/compile/env.rs
@@ -145,8 +145,26 @@ 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
@@ -157,10 +175,7 @@ pub fn compile_env_with_options(
     scan.source_contracts.iter().min_by_key(|name| name.pretty())
   {
     return Err(CompileError::UnsupportedExpr {
-      desc: format!(
-        "source binder contracts are not supported by this compiler yet: {}",
-        name.pretty()
-      ),
+      desc: format!("unresolved source binder contracts: {}", name.pretty()),
     });
   }
   let graph = scan.graph;
@@ -1025,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 effec1db9..d700ef69d 100644
--- a/crates/compile/src/graph.rs
+++ b/crates/compile/src/graph.rs
@@ -397,7 +397,7 @@ mod tests {
         .install(|| compile_env_with_options(&env, CompileOptions::default()));
       assert!(
         matches!(result, Err(ixon::CompileError::UnsupportedExpr { desc })
-        if desc == "source binder contracts are not supported by this compiler yet: AAnnotated")
+        if desc == "unresolved source binder contracts: AAnnotated")
       );
     }
   }
@@ -679,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/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_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
index 32299383f..005bbdbb6 100644
--- a/docs/source-contracts.md
+++ b/docs/source-contracts.md
@@ -1,206 +1,202 @@
-# Source contracts for the Aiur frontend
-
-The frontend elaborates binder annotations into source contracts and resolves
-their occurrences before canonicalization or sharing. It supports usage,
-bound-value ownership, declaration region parameters, and measure proposals.
-
-**Current boundary:** syntax, source binding, declaration telescope consistency,
-persistent registration, and pure input export. Resource/borrow checking, the
-Aiur DSL, Ixon contract emission, and artifact export remain subsequent work.
-Both production environment compilers reject marked source before emission.
-`compileLeanInput` also rejects contracts supplied separately from source
-markers, after validating the explicit input.
-
-## Pure input boundary
-
-`Ix.Compile.CompileInput` contains selected `(Name × ConstantInfo)` entries, an
-explicit array of `SourceContract` records, and optional `MeasureHint` records.
-The semantic contract array has no default. `CompileInput.plain` is the explicit
-convenience constructor for ordinary source without contracts.
-Resolution rejects that constructor's result if the source contains annotations.
-
-`CompileInput.resolve` validates this data without accessing a Lean environment:
-
-- Selected names must match their constants and be unique.
-- Each contract names a selected declaration through an exact source snapshot.
-  Comparison includes the type, body, universe parameters, declaration fields,
-  binder information, names, and metadata. A hash match alone is insufficient.
-- A binder site is a type/body root and a structural expression path. It must
-  identify an actual lambda or forall. Names and source offsets are not site IDs.
-- Repeated sites, conflicting type/body usage, input ownership or region bounds,
-  result ownership attached to a lambda, and unsupported telescope
-  correspondences fail with a structured `SourceContractError`.
-- Result ownership applies separately to each arrow. An unspecified result is
-  shared; an unspecified binder usage is many. An implicit binder is not
-  automatically erased.
-- Bound-value ownership (`owned`) is independent of arrow-result ownership
-  (`resultOwned`). Region references must name distinct declaration parameters
-  and resolve to indices in binding order.
-- Resolved records are sorted by declaration name and structural site, making
-  registration order irrelevant to their presentation. Production semantic
-  addressing must still be determined after actual mode emission.
-
-Resolved records are data, not resource-validity proofs. This checker does not
-establish linear use, unique ownership, nested function-type correspondence,
-termination, source typechecking, or erasure safety. A compiler must validate its
-accepted fragment and transport or reject every explicit contract through its
-rewrites before emitting an artifact.
-
-## Registering and exporting
-
-`SourceContract.ofTelescope source requests` expands declaration shorthand to
-separate type and body sites. Selectors can use a zero-based position or an
-unambiguous binder name. Positions count implicit and instance arguments.
-Metadata wrappers are traversed explicitly; the resolver does not normalize
-types or bodies. In particular, a function alias requiring normalization to
-expose a lambda receives `missingBodyBinder`.
-
-For a closed identity declaration, this request specifies the first binder as
-linear and its arrow result as unique:
+# Source contracts for the Ix frontend
 
-```lean
-SourceContract.ofTelescope source #[
-  { binder := .position 0, uses := .linear, resultOwned := some .unique }
-]
-```
+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 resulting type site is `⟨.type, []⟩` and body site is `⟨.body, []⟩`. The
-body site carries no result ownership. Selecting the second argument of a curried
-declaration changes only that arrow's result ownership.
+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.
 
-`registerSourceContract` and `registerMeasureHint` add checked records to
-persistent environment extensions. Disjoint contract patches accumulate.
-Imported patches are retained rather than overwritten by declaration name,
-allowing `compileInputFromEnv env selected` to detect conflicting imported
-registrations. It exports only the selected declarations' records and runs the
-pure validator before returning the input.
+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.
 
-Compiler loading must use the full-content Lean environment, including opaque
-bodies and imported declarations. The imported-module fixture tests this in a
-separate Lean process; annotations are not reconstructed by rerunning the
-producer module's registration commands.
+The complete semantic and binary design is in [Ixon v3](Ixon-v3.md).
 
-## Measure proposals
+## Modes
 
-Measure hints carry a source snapshot, a selector resolved to an elaborated
-input position, and an optional positive fixed-step proposal. Each declaration
-has its own position; a single raw index is not shared across mutual members.
-The hint adds no runtime argument, performs no decrement, and certifies neither
-termination nor a target cycle bound. Measure hints remain separate from the
-semantic binder contract array and can be registered on annotated declarations.
-A production regression checks that a hint-only change preserves ordinary bytes.
+| 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 |
 
-## Surface syntax
+`~!` 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.
 
-The implemented usage spellings are `(0 x : A)` for erased, `(1 x : A)` for linear,
-`(& x : A)` for affine, and `(x : A)` for many. `&` is the selected affine marker.
-Import `Ix.Compile.SourceContract.Elab` to enable the syntax:
+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
 
-regions 'a in
-def keep (!&'a x : @& Nat) : Nat := x
+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
 ```
 
-The selected ownership spelling is `!` before the variable name, with shared
-ownership implicit. Prefix components appear in ownership, usage, region order:
+These are declarations of intent. The source layer records their contracts;
+the resource checker determines which programs satisfy them.
 
-```lean
-(! x : A)       -- unique, unrestricted use
-(!1 x : A)      -- unique, exactly one use
-(!& x : A)      -- unique, at most one use
-(!&'a x : A)    -- unique, at most one use, bounded by region a
-(&'a x : A)     -- shared, at most one use, bounded by region a
-('a x : A)      -- shared, unrestricted use, bounded by region a
+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
 ```
 
-All these annotations belong to the binder. A region bound is independent of
-ownership; a region-bounded value need not be a shared loan. Syntax does not
-create a loan or establish uniqueness by itself. The annotation group is compact
-and is separated from the variable name by a space, including `(! x : A)`.
-
-The parser supports `def` header binders in explicit `(...)`, implicit `{...}`,
-strict implicit `⦃...⦄`, and named instance `[...]` forms. Each annotated binder
-has one name and an explicit type. Ordinary binders can be mixed with annotated
-ones. Inferred return types, auto-implicit parameters, dependent binders, private
-definitions, and declaration attributes are covered by fixtures. Annotations on
-`fun`, `forall`, `let`, and other declaration commands remain unsupported.
-
-`regions 'a 'b in <command>` introduces an ordered parameter table for that
-command. Nested commands extend the table, which is restored afterward.
-Duplicate parameters and unbound uses are errors. This introduces region
-parameters, not a runtime borrow operation or lexical loan scope. Ordinary Lean
-character literals and identifiers named `regions` retain their ordinary syntax.
-
-Binder ownership requires a richer contract than the current Ixon v2
-arrow-result field: `! x` must not silently set the ownership of the function's
-result. Result ownership syntax, lexical borrow scopes, and the portable region
-representation remain design work.
-
-Lean already accepts `(x : @& A)` as a native borrowing annotation. Since Lean
-4.30, the compiler can honor it on ordinary and local functions; it remains a
-best-effort reference-counting hint that inference may override, not a checked
-region or uniqueness contract. It stays orthogonal to our binder prefixes;
-`(!&'a x : @& A)` retains the native annotation's singleton outer metadata
-wrapper independently. See the
-[Lean 4.30 release notes](https://lean-lang.org/doc/reference/latest/releases/v4.30.0/).
-
-## Region identity and alpha-invariance
-
-Regions resolve to declaration-local indices: `regions 'a 'b in` binds `'a` at
-0 and `'b` at 1. Consistently renaming the parameters and their uses preserves
-the resolved assertions. Imported-module tests compare
-`ResolvedSourceContract.semantics` for definitions with renamed region and term
-binders, including multiple regions.
-
-That projection contains the region parameter count, occurrence paths, usage,
-input/result ownership, and indexed references. It excludes diagnostic names and
-the source snapshot. Raw records deliberately retain names and the exact source
-for stale-source detection; they must not become artifact hash inputs. The
-projection also remains source data, with paths into the elaborated tree.
-
-**Regions are not represented in emitted Ixon yet.** A future encoding needs
-region binders and indexed references in a namespace separate from term
-variables, with names kept as presentation data. Lexical borrow scopes need
-binding and escape rules. Byte/address equality under alpha-renaming remains an
-acceptance gate for that implementation.
-
-## Elaboration markers
-
-`SourceContract/Syntax.lean` parses annotated headers, and `Elab.lean` delegates
-ordinary declaration elaboration to Lean. Versioned binder-domain markers use
-the reserved `ix.source.binder` metadata namespace. `Marker.lean` rejects unknown
-versions/fields, duplicate fields, malformed values, and overflowing modes.
-Production guards detect reserved keys even if the marker is malformed.
-
-`SourceContract.fromAnnotations` reconstructs records from actual elaborated
-occurrences. Lean can preserve header metadata in the declaration type while
-dropping it from generated lambdas. Pairing then requires a direct type/body
-telescope with matching names, binder information, and domains. The resolver
-does not infer mappings through normalization or other rewrites. Marked raw
-recursor rules are explicitly unsupported.
-
-## Validation
-
-Run the focused build and executable behavior checks:
-
-```sh
-lake build --wfail Tests.SourceContractMain Tests.Main
-lake exe source-contract-tests
-cargo test --release -p ix-compile source_contract
+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 runtime suite covers mode/site expectations, repeated equal terms, curried
-results, shadowed and implicit binders, source drift, conflicting records, and
-measure resolution. Driver checks exercise missing or unsupported contracts and
-the actual Rust FFI, including absence of output files when partial compilation
-is enabled. Rust tests check deterministic rejection across worker counts and
-native borrow metadata's semantic neutrality. The imported-module build gate
-checks ordinary and opaque bodies, implicit/instance positions, conflicting patches,
-registration accumulation, surface syntax, native borrowing metadata, invalid
-syntax, and alpha-renaming of region and term parameters.
-
-The same checks are registered with the primary `source-contract` test suite and
-the dedicated `source-contract-tests` executable. They validate source-contract
-resolution and export, not production Ixon mode bytes or backend certification.
+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/lakefile.lean b/lakefile.lean
index a1549a22b..d5a54ef55 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -163,6 +163,17 @@ 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

From 4487c7870c9dec50910f24d6aec7cf9d5cde5090 Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 16 Sep 2026 08:36:16 -0400
Subject: [PATCH 3/5] test(ixon): simplify v3 fixtures and validation harness

---
 Tests/Ix/IxonV3.lean    | 107 ++++++++++++-----------
 Tests/Ix/IxonV3FFI.lean |  19 +++--
 Tests/Ix/IxonV3VM.lean  | 185 ++++++++++++++++++----------------------
 Tests/Ix/Resource.lean  | 111 +++++++++++++++---------
 Tests/IxonV3Main.lean   |   7 +-
 5 files changed, 222 insertions(+), 207 deletions(-)

diff --git a/Tests/Ix/IxonV3.lean b/Tests/Ix/IxonV3.lean
index 30210975d..bf0e54592 100644
--- a/Tests/Ix/IxonV3.lean
+++ b/Tests/Ix/IxonV3.lean
@@ -7,9 +7,17 @@ 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", .lam .many (.sort 0) (.lam .many (.sort 0) (.lam .many (.sort 0) (.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)
@@ -27,37 +35,41 @@ 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 (String × Expr × ByteArray) := Id.run do
+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])
+      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}",
+        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])
+          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])
+        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
 
-def modeFixtures : List (String × Expr) := modeCases.map fun (label, expr, _) => (label, expr)
-
-def parseHex : List Char → Except String (List UInt8)
-  | [] => .ok []
-  | hi :: lo :: rest => do
-    let some hi := natOfHex hi | throw "invalid hex digit"
-    let some lo := natOfHex lo | throw "invalid hex digit"
-    return (hi * 16 + lo).toUInt8 :: (← parseHex rest)
-  | _ => .error "odd hex length"
+/-- 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)
@@ -74,43 +86,38 @@ def checkBytes (name : String) (expr : Expr) (expected : ByteArray) : IO Nat :=
       throw <| IO.userError s!"{name}: accepted truncation at {n}"
   return expected.size + 3
 
-def malformed : Array ByteArray := (#[] : Array ByteArray) ++ #[
-  .mk #[0x70], .mk #[0x80], .mk #[0x90],
-  .mk #[0x71, 0x71, 0x10, 0x11, 0x12],
-  .mk #[0x81, 0x07, 0x00, 0x81, 0x07, 0x00, 0x10],
-  .mk #[0x91, 0x17, 0x00, 0x91, 0x17, 0x00, 0x10],
-  .mk #[0xA4, 0x07, 0x00, 0x10, 0x10],
-  .mk #[0x18, 0x00], .mk #[0x28, 0x07, 0x00], .mk #[0x20, 0x80, 0x00],
-  .mk #[0x87, 0x07, 0x00, 0x10], .mk #[0x77, 0x10]
+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])
 ]
 
-def runGolden : IO Nat := do
-  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/expressions.txt"
-  let mut checks := 0
-  for (name, expr) in fixtures do
-    let some line := (file.splitOn "\n").find? (·.startsWith (name ++ " "))
-      | throw <| IO.userError s!"missing fixture {name}"
-    let some hex := (line.splitOn " ")[1]?
-      | throw <| IO.userError s!"missing bytes for {name}"
-    let expected ← match parseHex hex.toList with
-      | .ok bytes => pure (ByteArray.mk bytes.toArray)
-      | .error e => throw <| IO.userError e
-    checks := checks + (← checkBytes name expr expected)
-  for (name, expr, expected) in modeCases do
-    checks := checks + (← checkBytes name expr expected)
-  for bytes in malformed do
-    if (runGetExact getExpr bytes).toOption.isSome then
-      throw <| IO.userError s!"accepted noncanonical bytes {hexOfBytes bytes}"
-    checks := checks + 1
+/-- 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
-    for bytes in #[ByteArray.mk #[0x81, code.toUInt8, 0x00, 0x10],
-        ByteArray.mk #[0xA0, code.toUInt8, 0x00, 0x10, 0x10]] do
-      if (runGetExact getExpr bytes).toOption.isSome then
-        throw <| IO.userError s!"accepted reserved contract bits {code}"
-      checks := checks + 1
+    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
-    if (runGetExact getExpr (.mk #[0x91, code.toUInt8, 0x00, 0x10])).toOption.isSome then
-      throw <| IO.userError s!"accepted reserved forall bits {code}"
+    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
 
diff --git a/Tests/Ix/IxonV3FFI.lean b/Tests/Ix/IxonV3FFI.lean
index b063a22f2..6c0f16af2 100644
--- a/Tests/Ix/IxonV3FFI.lean
+++ b/Tests/Ix/IxonV3FFI.lean
@@ -11,9 +11,9 @@ open Ixon
 @[extern "rs_eq_constant_serialization"] opaque equalConstantBytes : @& Constant → @& ByteArray → Bool
 @[extern "rs_expr_hash_matches"] opaque equalSharingHash : @& Expr → @& Address → Bool
 
-def runFFI : IO Nat := do
+def runFFI (cases : List ExprCase) : IO Nat := do
   let mut checks := 0
-  for (name, expr) in fixtures ++ modeFixtures do
+  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
@@ -22,20 +22,21 @@ def runFFI : IO Nat := 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 := (fixtures[1]!).2
+  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 ConstantInfo := #[
-    .defn defn, .recr recr, .axio ⟨true, 5, typ⟩,
-    .quot ⟨.lift, 5, typ⟩, .muts #[.defn defn, .indc ind, .recr recr]]
-  for info in infos do
+  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 "declaration FFI roundtrip differs"
+      throw <| IO.userError s!"{name}: declaration FFI roundtrip differs"
     unless equalConstantBytes c (serConstant c) do
-      throw <| IO.userError "declaration Lean/Rust bytes differ"
+      throw <| IO.userError s!"{name}: declaration Lean/Rust bytes differ"
     checks := checks + 2
   return checks
 
diff --git a/Tests/Ix/IxonV3VM.lean b/Tests/Ix/IxonV3VM.lean
index a2986475c..e33a27688 100644
--- a/Tests/Ix/IxonV3VM.lean
+++ b/Tests/Ix/IxonV3VM.lean
@@ -55,27 +55,63 @@ def codecToplevel : Except Aiur.Global Aiur.Source.Toplevel := do
 def codecBuffer (bytes : ByteArray) : Aiur.IOBuffer :=
   (default : Aiur.IOBuffer).extend 0 #[0] (bytes.data.map .ofUInt8)
 
-def checkVMBytes (env : AiurTestEnv) (name : String) (bytes : ByteArray)
-    (accept : Bool) (fnName : Lean.Name := `ixon_expr_codec) : IO Nat := do
+/-- 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 "missing VM codec entrypoint"
-  let buffer := codecBuffer bytes
-  let executed := env.compiled.bytecode.execute index #[] buffer
+    | 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!"{name}: VM unexpectedly accepted or changed output"
+      throw <| IO.userError s!"{label}: VM unexpectedly accepted or changed output"
   | .error e =>
-    if accept then throw <| IO.userError s!"{name}: VM execution failed: {e}"
-  let (interpreted, state) := Aiur.runFunction env.decls (.mk fnName) [] buffer
+    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!"{name}: source interpretation unexpectedly accepted or changed output"
+      throw <| IO.userError s!"{label}: source interpretation unexpectedly accepted or changed output"
   | .error e =>
-    if accept then throw <| IO.userError s!"{name}: source interpretation failed: {e}"
-  return 2
+    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
@@ -124,67 +160,40 @@ def replaceClaimBytes (witness : IxVM.ClaimHarness.ClaimWitness) (bytes : ByteAr
     inputIOBuffer := witness.inputIOBuffer.extend 0 key (bytes.data.map .ofUInt8) }
 
 def checkVMClaim (env : AiurTestEnv) (label : String)
-    (witness : IxVM.ClaimHarness.ClaimWitness) (accept : Bool) : IO Nat := do
-  let index := env.compiled.getFuncIdx witness.funcName |>.get!
-  let executed := env.compiled.bytecode.execute index witness.input witness.inputIOBuffer
-  match executed with
-  | .ok (out, io, _) =>
-    unless accept && out.isEmpty && io == witness.inputIOBuffer do
-      throw <| IO.userError s!"{label}: VM claim unexpectedly accepted or changed output"
-  | .error e =>
-    if accept then throw <| IO.userError s!"{label}: VM claim execution failed: {e}"
-  match env.compiled.bytecode.executeIxVM index witness.input witness.inputIOBuffer with
-  | .ok (out, io, counts) =>
-    let .ok (expectedOut, expectedIO, expectedCounts) := executed
-      | throw <| IO.userError s!"{label}: generated VM accepted a rejected claim"
-    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 claim execution failed: {e}"
-  let name := Aiur.Global.mk witness.funcName
-  let inputTypes := match env.decls.getByKey name with
-    | some (.function f) => f.inputs.map (·.2)
-    | _ => []
-  let inputs := Aiur.unflattenInputs env.decls witness.input inputTypes
-  match Aiur.runFunction env.decls name inputs witness.inputIOBuffer with
-  | (.ok _, state) =>
-    unless accept && state.ioBuffer == witness.inputIOBuffer do
-      throw <| IO.userError s!"{label}: claim interpreter unexpectedly accepted"
-  | (.error e, _) =>
-    if accept then throw <| IO.userError s!"{label}: claim interpretation failed: {e}"
-  return 3
+    (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, target) := Tests.ResourceAddressed.store base constant
-  let env := { env with anonHints := env.anonHints.insert target .opaque }
+  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
-  for claim in [Ix.Claim.check target none, .checkEnv tree.root none,
-      .reveal target (.defn none none none
-        (some (Address.blake3 (Ixon.runPut (Ixon.putExpr
-          (.all Tests.ResourceAddressed.linearLocal .localShared (.ref 0 #[]) (.ref 0 #[])))))) none),
-      .contains tree.root target] do
+  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 "v3 claim" witness true)
+    checks := checks + (← checkVMClaim vm name witness true)
     let bytes := Ix.Claim.ser claim
-    for bad in [bytes.push 0, bytes.set! 1 2, bytes.set! 2 255,
-        bytes.extract 0 (bytes.size - 1)] do
-      checks := checks + (← checkVMClaim vm "invalid v3 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, target) := Tests.ResourceAddressed.store base
+  let (escaping, escapingTarget) := Tests.ResourceAddressed.store base
     (Tests.ResourceAddressed.identity unit Tests.ResourceAddressed.linearLocal .shared)
-  let escaping := { escaping with anonHints := escaping.anonHints.insert target .opaque }
-  let witness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness escaping (.check target none))
+  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"
@@ -196,61 +205,31 @@ def runVMClaims : IO Nat := do
   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)
-  -- The positive proof uses the valid annotated target from the original env.
-  let validTarget := Tests.ResourceAddressed.store base constant |>.2
   let checkWitness ← IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness env (.check validTarget none))
-  let index := vm.compiled.getFuncIdx checkWitness.funcName |>.get!
-  let (claim, proof, _) ← IO.ofExcept
-    (vm.aiurSystem.prove index checkWitness.input checkWitness.inputIOBuffer)
-  IO.ofExcept (vm.aiurSystem.verify claim (Aiur.Proof.ofBytes proof.toBytes))
+  checkVMProof vm checkWitness.funcName checkWitness.input checkWitness.inputIOBuffer
   return checks + 1
 
-def runVM : IO Nat := do
+def runVM (cases : List ExprCase) : IO Nat := do
   let env ← IO.ofExcept (AiurTestEnv.build codecToplevel)
   let mut checks := 0
-  let file ← IO.FS.readFile "Tests/Fixtures/ixon-v3/expressions.txt"
-  let mut cases := modeCases.map fun (name, _, bytes) => (name, bytes)
-  for (name, _) in fixtures do
-    let some line := (file.splitOn "\n").find? (·.startsWith (name ++ " "))
-      | throw <| IO.userError s!"missing fixture {name}"
-    let some hex := (line.splitOn " ")[1]?
-      | throw <| IO.userError s!"missing fixture bytes {name}"
-    let bytes ← IO.ofExcept (parseHex hex.toList)
-    cases := cases ++ [(name, ByteArray.mk bytes.toArray)]
-  for (name, bytes) in cases do
-    checks := checks + (← checkVMBytes env name bytes true)
-    checks := checks + (← checkVMBytes env s!"{name}-trailing" (bytes.push 0) false)
-    for n in [:bytes.size] do
-      checks := checks + (← checkVMBytes env s!"{name}-truncated-{n}" (bytes.extract 0 n) false)
-  for bytes in malformed do
-    checks := checks + (← checkVMBytes env "malformed" bytes false)
+  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)
-  for code in [16:256] do
-    for bytes in #[ByteArray.mk #[0x81, code.toUInt8, 0x00, 0x10],
-        ByteArray.mk #[0xA0, code.toUInt8, 0x00, 0x10, 0x10]] do
-      checks := checks + (← checkVMBytes env "reserved-binder-bits" bytes false)
-  for code in [64:256] do
-    checks := checks + (← checkVMBytes env "reserved-forall-bits"
-      (.mk #[0x91, code.toUInt8, 0x00, 0x10]) false)
   -- Independently authored declaration bytes cover the six unchanged headers.
-  for hex in [
-      "d006050010000000",
-      "d101050102030400010310000000",
-      "d2010500000000",
-      "d3020500000000",
-      "c101000502030001010501020300000000"] do
-    let bytes ← IO.ofExcept (parseHex hex.toList)
-    let bytes := ByteArray.mk bytes.toArray
-    checks := checks + (← checkVMBytes env "declaration" bytes true `ixon_const_codec)
-    checks := checks + (← checkVMBytes env "declaration-trailing" (bytes.push 0) false `ixon_const_codec)
-    for n in [:bytes.size] do
-      checks := checks + (← checkVMBytes env "declaration-truncated" (bytes.extract 0 n) false `ixon_const_codec)
+  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]
-  let index := env.compiled.getFuncIdx `ixon_expr_codec |>.get!
-  let (claim, proof, _) ← IO.ofExcept (env.aiurSystem.prove index #[] (codecBuffer bytes))
-  let proof := Aiur.Proof.ofBytes proof.toBytes
-  IO.ofExcept (env.aiurSystem.verify claim proof)
+  checkVMProof env `ixon_expr_codec #[] (codecBuffer bytes)
   -- Execute and prove the actual production claim boundary as well.
   return checks + 2 + (← runVMClaims)
 
diff --git a/Tests/Ix/Resource.lean b/Tests/Ix/Resource.lean
index f217d2226..5f49a5994 100644
--- a/Tests/Ix/Resource.lean
+++ b/Tests/Ix/Resource.lean
@@ -98,10 +98,9 @@ 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"⟩,
-  ⟨"linear unique transfer", arr (b .linear .unique) .unique,
-    lam (b .linear .unique) (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"⟩,
@@ -116,6 +115,16 @@ def cases : Array Case := #[
     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,
@@ -123,6 +132,8 @@ def cases : Array Case := #[
       (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,
@@ -133,6 +144,8 @@ def cases : Array Case := #[
     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,
@@ -158,8 +171,14 @@ def cases : Array Case := #[
   ⟨"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"⟩,
-  ⟨"unregistered projection has no optimistic rule", arr (b .many .unique),
-    lam (b .many .unique) (.prj 0 0 (v 0)), "unsupported"⟩,
+  ⟨"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),
@@ -172,6 +191,23 @@ def cases : Array Case := #[
     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),
@@ -184,50 +220,27 @@ def cases : Array Case := #[
     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"⟩,
-  ⟨"fresh inner linear binder under many demand", arr (b .many),
-    lam (b .many) (call 5 (bind (b .linear) (v 0) (v 0))), "ok"⟩,
-  ⟨"discarding borrow before narrowing fresh result", arr (b .many .unique) .localShared,
-    lam (b .many .unique) (borrow (v 0) (call 1 (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"⟩,
-  ⟨"selection cannot bypass its rule through a callback", arr (b .many) .shared natTy (choiceType .shared),
-    lam (b .many) (ref 6), "unsupported"⟩,
-  ⟨"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"⟩,
-  ⟨"branch analysis follows a shared application head", arr (b .linear),
-    lam (b .linear) (.app (.app (.app (.share 1) zero) (v 0)) (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"⟩,
   ⟨"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"⟩,
-  ⟨"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"⟩
+    lam (b .erased) (.app (lam (b .erased) zero (arr (b .many))) (v 0)) (arr (b .many)), "ok"⟩
 ]
 
-def additionalCases : Array Case := Id.run do
+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))
@@ -248,18 +261,23 @@ def additionalCases : Array Case := Id.run do
     ⟨"higher order contract mismatch", mismatched, mismatchBody, "type"⟩
   ]
 
-def allCases : Array Case := cases ++ additionalCases
+def allCases : Array Case := cases ++ higherOrderCases
 
-def run : IO Unit := do
+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 (file.splitOn "\n").contains line do
+    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"
@@ -272,13 +290,22 @@ def run : IO Unit := do
          (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}"
-  -- Budget exhaustion is an error, including cycles through open sharing.
+      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"
-  IO.println s!"Resource checker: {allCases.size + 65} positive/negative and mode checks passed"
+
+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
 
diff --git a/Tests/IxonV3Main.lean b/Tests/IxonV3Main.lean
index 77a5cd94a..005803403 100644
--- a/Tests/IxonV3Main.lean
+++ b/Tests/IxonV3Main.lean
@@ -22,11 +22,12 @@ def main (args : List String) : IO Unit := do
     Tests.IxonV3Handoff.writeArtifacts "/tmp/ixon-v3-handoff"
   else
     Tests.IxonV3Handoff.check "Tests/Fixtures/ixon-v3/handoff"
-  let checks ← Tests.IxonV3.runGolden
+  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
+  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
+  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"

From 2afb4eac340cd4cbe94ed9e507561f3ad8375ebd Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 16 Sep 2026 09:06:49 -0400
Subject: [PATCH 4/5] fix(nix): include shared Ixon v3 test fixtures

---
 flake.nix | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

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";

From 5f5942e1e3d048c10ac8b379f3d2ccd1a8f53a4b Mon Sep 17 00:00:00 2001
From: "John C. Burnham" <john@agathic.com>
Date: Wed, 16 Sep 2026 16:20:00 -0400
Subject: [PATCH 5/5] fix(ffi): preserve NUL bytes in Lean source strings

---
 Tests/FFI/Ix.lean            | 36 ++++++++++++++++++++++++++++++++++++
 crates/ffi/src/ix/data.rs    |  8 ++++----
 crates/ffi/src/ix/expr.rs    |  3 ++-
 crates/ffi/src/ix/name.rs    |  2 +-
 crates/ffi/src/lean_build.rs | 16 ++++++++++------
 5 files changed, 53 insertions(+), 12 deletions(-)

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/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/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()
     },
   }